# Paquetería necesaria:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import plotly.subplots as sp
import plotly.graph_objects as go
import seaborn as sns
import plotly.express as px
import math
import pickle
import optuna
import optuna.visualization.matplotlib as opt_viz
import subprocess
import time
from IPython.display import display, HTML

# Apertura del servidor guardado de Optuna:
import webbrowser

# Modelización:
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance,PartialDependenceDisplay
from sklearn.preprocessing import StandardScaler, QuantileTransformer,OneHotEncoder
from sklearn.model_selection import train_test_split,StratifiedKFold
from sklearn.impute import SimpleImputer
from sklearn.metrics import (
    roc_auc_score,
    average_precision_score,
    recall_score,
    f1_score,
    precision_score,
    accuracy_score,
    brier_score_loss,
    confusion_matrix,
    ConfusionMatrixDisplay,
    auc,
    precision_recall_curve
)
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
from xgboost import XGBClassifier
import xgboost as xgb
from lightgbm import LGBMClassifier
from sklearn.linear_model import LogisticRegression
from pytorch_tabnet.tab_model import TabNetClassifier

from statsmodels.stats.outliers_influence import variance_inflation_factor
import scipy.stats as stats
from scipy.stats import ks_2samp
from skimage.filters import threshold_otsu

# XAI
import shap
import lime
import lime.lime_tabular
import os

# Paleta de colores basada en azules para unificar la visualización de datos:
custom_palette = ["#003f5c", "#2f4b7c", "#665191", "#a05195", "#d45087", "#f95d6a"]
sns.set_palette(custom_palette)

c:\Program Files\Python311\Lib\site-packages\tqdm\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
  from .autonotebook import tqdm as notebook_tqdm

# Carga de los conjuntos de datos de train y test, respectivamente desde la fuente de datos orígen (local):
train = pd.read_csv("./train.csv")
test = pd.read_csv("./test.csv")

# Instancia de visualización raw tras la carga:
print(f"Dimensiones del dataset de entrenamiento: {train.shape}")
print(f"Dimensiones del dataset de test: {test.shape}")

# Muestro las primeras filas
train.head()

Dimensiones del dataset de entrenamiento: (595212, 59)
Dimensiones del dataset de test: (892816, 58)

# Revisión de datos inicial:
train.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 595212 entries, 0 to 595211
Data columns (total 59 columns):
 #   Column          Non-Null Count   Dtype  
---  ------          --------------   -----  
 0   id              595212 non-null  int64  
 1   target          595212 non-null  int64  
 2   ps_ind_01       595212 non-null  int64  
 3   ps_ind_02_cat   595212 non-null  int64  
 4   ps_ind_03       595212 non-null  int64  
 5   ps_ind_04_cat   595212 non-null  int64  
 6   ps_ind_05_cat   595212 non-null  int64  
 7   ps_ind_06_bin   595212 non-null  int64  
 8   ps_ind_07_bin   595212 non-null  int64  
 9   ps_ind_08_bin   595212 non-null  int64  
 10  ps_ind_09_bin   595212 non-null  int64  
 11  ps_ind_10_bin   595212 non-null  int64  
 12  ps_ind_11_bin   595212 non-null  int64  
 13  ps_ind_12_bin   595212 non-null  int64  
 14  ps_ind_13_bin   595212 non-null  int64  
 15  ps_ind_14       595212 non-null  int64  
 16  ps_ind_15       595212 non-null  int64  
 17  ps_ind_16_bin   595212 non-null  int64  
 18  ps_ind_17_bin   595212 non-null  int64  
 19  ps_ind_18_bin   595212 non-null  int64  
 20  ps_reg_01       595212 non-null  float64
 21  ps_reg_02       595212 non-null  float64
 22  ps_reg_03       595212 non-null  float64
 23  ps_car_01_cat   595212 non-null  int64  
 24  ps_car_02_cat   595212 non-null  int64  
 25  ps_car_03_cat   595212 non-null  int64  
 26  ps_car_04_cat   595212 non-null  int64  
 27  ps_car_05_cat   595212 non-null  int64  
 28  ps_car_06_cat   595212 non-null  int64  
 29  ps_car_07_cat   595212 non-null  int64  
 30  ps_car_08_cat   595212 non-null  int64  
 31  ps_car_09_cat   595212 non-null  int64  
 32  ps_car_10_cat   595212 non-null  int64  
 33  ps_car_11_cat   595212 non-null  int64  
 34  ps_car_11       595212 non-null  int64  
 35  ps_car_12       595212 non-null  float64
 36  ps_car_13       595212 non-null  float64
 37  ps_car_14       595212 non-null  float64
 38  ps_car_15       595212 non-null  float64
 39  ps_calc_01      595212 non-null  float64
 40  ps_calc_02      595212 non-null  float64
 41  ps_calc_03      595212 non-null  float64
 42  ps_calc_04      595212 non-null  int64  
 43  ps_calc_05      595212 non-null  int64  
 44  ps_calc_06      595212 non-null  int64  
 45  ps_calc_07      595212 non-null  int64  
 46  ps_calc_08      595212 non-null  int64  
 47  ps_calc_09      595212 non-null  int64  
 48  ps_calc_10      595212 non-null  int64  
 49  ps_calc_11      595212 non-null  int64  
 50  ps_calc_12      595212 non-null  int64  
 51  ps_calc_13      595212 non-null  int64  
 52  ps_calc_14      595212 non-null  int64  
 53  ps_calc_15_bin  595212 non-null  int64  
 54  ps_calc_16_bin  595212 non-null  int64  
 55  ps_calc_17_bin  595212 non-null  int64  
 56  ps_calc_18_bin  595212 non-null  int64  
 57  ps_calc_19_bin  595212 non-null  int64  
 58  ps_calc_20_bin  595212 non-null  int64  
dtypes: float64(10), int64(49)
memory usage: 267.9 MB

# Resumen de la totalidad de las variables:

def generar_resumen(df, threshold_cual, solo_cuantitativas=False):
    """
    Genera una tabla resumen de las variables en un DataFrame,
    clasificándolas por tipo y ordenándolas en consecuencia.
    
    Parámetros:
    - df: DataFrame de entrada.
    - threshold_cual: Umbral para considerar una variable como cualitativa o continua.
    - solo_cuantitativas: Si es True, filtra solo las variables cuantitativas (continua o cont/cual).
    Retorno:
    - Un DataFrame con la información formateada.
    """
    # Elimino la columna 'id' si está presente
    temp_df = df.drop(columns=["id"], errors="ignore")

    summary = pd.DataFrame(temp_df.dtypes, columns=["Data Type"])
    summary["num_na"] = (temp_df == -1).sum().values
    summary["num_unique"] = temp_df.nunique().values
    summary["Category"] = None
    summary["Variable Type"] = None 

    for col in temp_df.columns:
        num_uniques = summary.loc[col, "num_unique"]
        
        if "bin" in col or col == "target":
            summary.loc[col, "Category"] = "Binaria"
        elif "cat" in col:
            summary.loc[col, "Category"] = "Cualitativa"
        elif pd.api.types.is_numeric_dtype(temp_df[col]):  
            if np.issubdtype(temp_df[col].dtype, np.floating): 
                summary.loc[col, "Category"] = "Continua"
            elif np.issubdtype(temp_df[col].dtype, np.integer): 
                summary.loc[col, "Category"] = "Cont/Cual"
        else:
            summary.loc[col, "Category"] = "Unknown" 

        # Asigno Variable Type basado en num_unique:
        if num_uniques <= threshold_cual:
            summary.loc[col, "Variable Type"] = "Cualitativa"
        else:
            summary.loc[col, "Variable Type"] = "Continua"

    # Filtrado si solo se quieren cuantitativas para futura viz:
    if solo_cuantitativas:
        summary = summary[summary["Variable Type"].isin(["Continua"])]

    category_order = {"Binaria": 1, "Cualitativa": 2, "Continua": 3, "Cont/Cual": 4}
    summary["Category Order"] = summary["Category"].map(category_order)
    summary = summary.sort_values(by="Category Order")
    summary = summary.drop(columns=["Category Order"])

    cmap = sns.light_palette("skyblue", as_cmap=True)
    
    return summary.style.background_gradient(cmap=cmap)

# Ejecuto la tabla resumen con el dataset original y un threshold para considerar una variable como "contínua", 
# cuando supera los 20 valores distintos sobre el conjunto total::
threshold_cual=20
generar_resumen(train,threshold_cual)

# Visualizo solo continuas asumidas:
generar_resumen(train,threshold_cual, True)

# Segmentación/separación de variables en función del threshold anteriormente definido:

def classify_variables(df, target, threshold_cual=20):
    """
    Clasifica las variables en binarias, categóricas o continuas, sin modificar el dataset.
    
    Parámetros:
    - df: DataFrame con los datos.
    - target: Nombre de la variable objetivo (se excluye de la clasificación).
    - threshold_cual: Número máximo de valores únicos para considerar una variable como categórica.
    
    Retorno:
    - binary_vars: Lista de variables binarias.
    - categorical_vars: Lista de variables categóricas.
    - continuous_vars: Lista de variables continuas.
    """
    # Identificar la columna ID (suponiendo que es la primera columna)
    id_column = df.columns[0]

    binary_vars = []
    categorical_vars = []
    continuous_vars = []

    for col in df.columns:
        if col in [target, id_column]:  # Excluir target e ID
            continue
        unique_values = df[col].nunique()

        if unique_values == 2:
            binary_vars.append(col)
        elif unique_values <= threshold_cual:
            categorical_vars.append(col)
        else:
            continuous_vars.append(col)

    return binary_vars, categorical_vars, continuous_vars

# Aplicar la función al dataset train
target='target'
binary_vars, categorical_vars, continuous_vars = classify_variables(train, target)

# Muestra del resultado
print(f"Variables binarias: {binary_vars}\n")
print(f"Variables categóricas: {categorical_vars}\n")
print(f"Variables continuas: {continuous_vars}\n")

Variables binarias: ['ps_ind_06_bin', 'ps_ind_07_bin', 'ps_ind_08_bin', 'ps_ind_09_bin', 'ps_ind_10_bin', 'ps_ind_11_bin', 'ps_ind_12_bin', 'ps_ind_13_bin', 'ps_ind_16_bin', 'ps_ind_17_bin', 'ps_ind_18_bin', 'ps_car_08_cat', 'ps_calc_15_bin', 'ps_calc_16_bin', 'ps_calc_17_bin', 'ps_calc_18_bin', 'ps_calc_19_bin', 'ps_calc_20_bin']

Variables categóricas: ['ps_ind_01', 'ps_ind_02_cat', 'ps_ind_03', 'ps_ind_04_cat', 'ps_ind_05_cat', 'ps_ind_14', 'ps_ind_15', 'ps_reg_01', 'ps_reg_02', 'ps_car_01_cat', 'ps_car_02_cat', 'ps_car_03_cat', 'ps_car_04_cat', 'ps_car_05_cat', 'ps_car_06_cat', 'ps_car_07_cat', 'ps_car_09_cat', 'ps_car_10_cat', 'ps_car_11', 'ps_car_15', 'ps_calc_01', 'ps_calc_02', 'ps_calc_03', 'ps_calc_04', 'ps_calc_05', 'ps_calc_06', 'ps_calc_07', 'ps_calc_08', 'ps_calc_09', 'ps_calc_11', 'ps_calc_12', 'ps_calc_13']

Variables continuas: ['ps_reg_03', 'ps_car_11_cat', 'ps_car_12', 'ps_car_13', 'ps_car_14', 'ps_calc_10', 'ps_calc_14']

# Vsualización de la tipología a alto nivel en nuestro dataset:
df_types = pd.DataFrame({
    "Variable": binary_vars + categorical_vars + continuous_vars,
    "Tipo": ["Binaria"] * len(binary_vars) + ["Categorica"] * len(categorical_vars) + ["Continua"] * len(continuous_vars)
})

sns.set(style="whitegrid", palette="Blues")

plt.figure(figsize=(20, 5))
ax = sns.countplot(data=df_types, y="Tipo", order=["Binaria", "Categorica", "Continua"])
plt.title("Distribución de Tipos de Variables en el Dataset")
plt.xlabel("Cantidad de Variables")
plt.ylabel("Tipo de Variable")
plt.show()

# Visualización del target:

target_counts = train["target"].value_counts().reset_index()
target_counts.columns = ["Clase", "Frecuencia"]
target_counts["Porcentaje"] = (target_counts["Frecuencia"] / target_counts["Frecuencia"].sum()) * 100
color_scale = ["#00274D", "#004488", "#0066CC", "#3399FF", "#66B2FF"]

fig = px.bar(target_counts, x="Clase", y="Frecuencia", text="Porcentaje",
             title="Distribución de la Variable Objetivo",
             labels={"Clase": "Clase", "Frecuencia": "Frecuencia"},
             color="Frecuencia", color_continuous_scale=color_scale)

fig.update_traces(texttemplate='%{text:.2f}%', textposition='outside')
fig.update_layout(xaxis=dict(tickmode='array', tickvals=[0, 1], ticktext=['Clase 0', 'Clase 1']),
                  coloraxis_showscale=False,
                  template="plotly_white")
fig.show()

# Variables Categóricas vs Target en Grid:

num_vars = len(categorical_vars)
num_cols = 3
num_rows = (num_vars // num_cols) + (num_vars % num_cols > 0)
fig_cat_target = sp.make_subplots(rows=num_rows, cols=num_cols, subplot_titles=categorical_vars)
row, col = 1, 1

for var in categorical_vars:
    df_target = train.groupby([var, "target"]).size().reset_index(name="count")
    trace = go.Bar(x=df_target[var], y=df_target["count"], marker_color=df_target["target"].map({0: "royalblue", 1: "darkblue"}), name=var)
    fig_cat_target.add_trace(trace, row=row, col=col)

    col += 1
    if col > num_cols:
        col = 1
        row += 1

fig_cat_target.update_layout(title="Distribución de Variables Categóricas por Target", showlegend=False, height=300 * num_rows)
fig_cat_target.show()

# Histogramas de Variables Continuas por Target en Grid:

num_vars_cont = len(continuous_vars)
num_rows_cont = (num_vars_cont // num_cols) + (num_vars_cont % num_cols > 0)
fig_cont_hist = sp.make_subplots(rows=num_rows_cont, cols=num_cols, subplot_titles=continuous_vars)

row, col = 1, 1
for var in continuous_vars:
    trace0 = go.Histogram(x=train[train["target"] == 0][var], name=f"{var} (Target=0)", opacity=0.6, marker_color="royalblue")
    trace1 = go.Histogram(x=train[train["target"] == 1][var], name=f"{var} (Target=1)", opacity=0.6, marker_color="darkblue")

    fig_cont_hist.add_trace(trace0, row=row, col=col)
    fig_cont_hist.add_trace(trace1, row=row, col=col)

    col += 1
    if col > num_cols:
        col = 1
        row += 1

fig_cont_hist.update_layout(title="Distribución de Variables Continuas por Target", showlegend=False, height=300 * num_rows_cont)
fig_cont_hist.show()

# Heatmap de Correlación entre Variables Continuas:

plt.figure(figsize=(20, 10))
corr_matrix = train[continuous_vars].corr()
sns.heatmap(corr_matrix, annot=True, cmap="Blues", fmt=".2f", linewidths=0.5)
plt.title("Mapa de Calor de Correlación entre Variables Continuas")
plt.show()

# Constancia situacional a nivel viaual de lo que representa las variables a nivel N/A en el conjunto de datos:

plt.figure(figsize=(25, 10))
sns.heatmap(train.replace(-1,np.nan).isnull(), cmap="Blues", cbar=False, yticklabels=False)
plt.title("Mapa de Valores Faltantes (-1 tratados como NaN)")
plt.show()

# Visualización ordenada de variables n/a:

train_na = (train == -1).sum()
train_na = train_na[train_na > 0]
train_na = train_na.sort_values(ascending=False)

df_na = pd.DataFrame({'Variable': train_na.index, 'num_na': train_na.values})
df_na = df_na.sort_values(by="num_na", ascending=False)

df_na

# Imputación de variables cuant. con NAs:

train_before = train.copy()
train[continuous_vars] = train[continuous_vars].replace(-1, np.nan)

# Imputo los NaN con la mediana, para a posteriori poder aplicar el quantile imputer:
normal_dist = QuantileTransformer(output_distribution='normal', random_state=42)
train[['ps_reg_03', 'ps_car_12', 'ps_car_14']] = train[['ps_reg_03', 'ps_car_12', 'ps_car_14']].fillna(train[['ps_reg_03', 'ps_car_12', 'ps_car_14']].median())
train[['ps_reg_03', 'ps_car_12', 'ps_car_14']] = normal_dist.fit_transform(train[['ps_reg_03', 'ps_car_12', 'ps_car_14']])

# Histogramas Antes vs Después de la Imputación ---
fig, axes = plt.subplots(3, 2, figsize=(16, 10))

for i, col in enumerate(['ps_reg_03', 'ps_car_12', 'ps_car_14']):

    sns.histplot(train_before[col].dropna(), kde=True, bins=30, ax=axes[i, 0], color="royalblue", alpha=0.6)
    axes[i, 0].set_title(f"Distribución de {col} Antes de la Imputación")

    sns.histplot(train[col], kde=True, bins=30, ax=axes[i, 1], color="darkblue", alpha=0.6)
    axes[i, 1].set_title(f"Distribución de {col} Después de la Imputación")

plt.tight_layout()
plt.show()

# Volvemos a visualizar la distr de NAs del dataset:
train.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 595212 entries, 0 to 595211
Data columns (total 59 columns):
 #   Column          Non-Null Count   Dtype  
---  ------          --------------   -----  
 0   id              595212 non-null  int64  
 1   target          595212 non-null  int64  
 2   ps_ind_01       595212 non-null  int64  
 3   ps_ind_02_cat   595212 non-null  int64  
 4   ps_ind_03       595212 non-null  int64  
 5   ps_ind_04_cat   595212 non-null  int64  
 6   ps_ind_05_cat   595212 non-null  int64  
 7   ps_ind_06_bin   595212 non-null  int64  
 8   ps_ind_07_bin   595212 non-null  int64  
 9   ps_ind_08_bin   595212 non-null  int64  
 10  ps_ind_09_bin   595212 non-null  int64  
 11  ps_ind_10_bin   595212 non-null  int64  
 12  ps_ind_11_bin   595212 non-null  int64  
 13  ps_ind_12_bin   595212 non-null  int64  
 14  ps_ind_13_bin   595212 non-null  int64  
 15  ps_ind_14       595212 non-null  int64  
 16  ps_ind_15       595212 non-null  int64  
 17  ps_ind_16_bin   595212 non-null  int64  
 18  ps_ind_17_bin   595212 non-null  int64  
 19  ps_ind_18_bin   595212 non-null  int64  
 20  ps_reg_01       595212 non-null  float64
 21  ps_reg_02       595212 non-null  float64
 22  ps_reg_03       595212 non-null  float64
 23  ps_car_01_cat   595212 non-null  int64  
 24  ps_car_02_cat   595212 non-null  int64  
 25  ps_car_03_cat   595212 non-null  int64  
 26  ps_car_04_cat   595212 non-null  int64  
 27  ps_car_05_cat   595212 non-null  int64  
 28  ps_car_06_cat   595212 non-null  int64  
 29  ps_car_07_cat   595212 non-null  int64  
 30  ps_car_08_cat   595212 non-null  int64  
 31  ps_car_09_cat   595212 non-null  int64  
 32  ps_car_10_cat   595212 non-null  int64  
 33  ps_car_11_cat   595212 non-null  int64  
 34  ps_car_11       595212 non-null  int64  
 35  ps_car_12       595212 non-null  float64
 36  ps_car_13       595212 non-null  float64
 37  ps_car_14       595212 non-null  float64
 38  ps_car_15       595212 non-null  float64
 39  ps_calc_01      595212 non-null  float64
 40  ps_calc_02      595212 non-null  float64
 41  ps_calc_03      595212 non-null  float64
 42  ps_calc_04      595212 non-null  int64  
 43  ps_calc_05      595212 non-null  int64  
 44  ps_calc_06      595212 non-null  int64  
 45  ps_calc_07      595212 non-null  int64  
 46  ps_calc_08      595212 non-null  int64  
 47  ps_calc_09      595212 non-null  int64  
 48  ps_calc_10      595212 non-null  int64  
 49  ps_calc_11      595212 non-null  int64  
 50  ps_calc_12      595212 non-null  int64  
 51  ps_calc_13      595212 non-null  int64  
 52  ps_calc_14      595212 non-null  int64  
 53  ps_calc_15_bin  595212 non-null  int64  
 54  ps_calc_16_bin  595212 non-null  int64  
 55  ps_calc_17_bin  595212 non-null  int64  
 56  ps_calc_18_bin  595212 non-null  int64  
 57  ps_calc_19_bin  595212 non-null  int64  
 58  ps_calc_20_bin  595212 non-null  int64  
dtypes: float64(10), int64(49)
memory usage: 267.9 MB

# ratificación tras la imputación:

train_na = (train == -1).sum()
train_na = train_na[train_na > 0]
train_na = train_na.sort_values(ascending=False)

df_na = pd.DataFrame({'Variable': train_na.index, 'num_na': train_na.values})
df_na = df_na.sort_values(by="num_na", ascending=False)

df_na

def gini_01(df, target, binary_vars, categorical_vars, continuous_vars):
    """
    Calcula el coeficiente de Gini para cada variable del dataset según su tipo:
    - Continuas: AUC-ROC -> Gini = 2 * AUC - 1
    - Binarias: AUC-ROC -> Gini = 2 * AUC - 1
    - Categóricas: One-hot encoding y promedio del Gini de cada categoría.
    """
    # Imputación de n/a real:
    df = df.replace(-1, np.nan)  # Reemplazo -1 por NaN para que no se tengan en cuenta, pero NO los elimino (efecto solo contra cualitativas)
    
    gini_dict = {}

    # Variables binarias y continuas: usamos AUC-ROC directamente
    for col in binary_vars + continuous_vars:
        try:
            auc = roc_auc_score(df[target], df[col])
            gini_dict[col] = 2 * auc - 1
        except:
            gini_dict[col] = np.nan 

    # Variables categóricas: One-hot encoding y cálculo de Gini por categoría
    for col in categorical_vars:
        temp_df_dummies = pd.get_dummies(df[col], prefix=col, drop_first=True)
        gini_scores = []
        for dummy_col in temp_df_dummies.columns:
            try:
                auc = roc_auc_score(df[target], temp_df_dummies[dummy_col])
                gini_scores.append(2 * auc - 1)
            except:
                gini_scores.append(np.nan)
        
        gini_dict[col] = np.nanmean(gini_scores)

    gini_df = pd.DataFrame(list(gini_dict.items()), columns=['Feature', 'Gini'])
    gini_df = gini_df.sort_values(by='Gini', ascending=False)

    return gini_df


def plot_gini_results(gini_df):
    """
    Visualiza el coeficiente de Gini en un gráfico de barras.
    """
    gini_df = gini_df.sort_values(by="Gini", ascending=False)
    gini_thresholds = {
        "Neutro": 0,
    }
    plt.figure(figsize=(20, 14))
    color = (0/255, 155/255, 200/255)

    ax = sns.barplot(y=gini_df["Feature"], x=gini_df["Gini"], color=color)
    for label, value in gini_thresholds.items():
        plt.axvline(x=value, color="red", linestyle="dashed", linewidth=2, label=f"{label} ({value:.2f})")

    plt.xlabel("Gini", fontsize=12)
    plt.ylabel("Feature", fontsize=12)
    plt.title("Gini de las Variables", fontsize=14, fontweight="bold")

    plt.legend()
    plt.show()


# --------------------------------------------------
#---------EJECUCIÓN y PLOT--------------------------
# --------------------------------------------------
gini_total = gini_01(train, target, binary_vars, categorical_vars, continuous_vars)
plot_gini_results(gini_total)

# --------------------------------------------------------------
# 2. Information Value (IV)-------------------------------------
# --------------------------------------------------------------

def iv_02(df, target_col, binary_vars, categorical_vars, continuous_vars, num_bins=10):
    """
    Calcula el Information Value (IV) para cada variable respecto al target.
    - Variables continuas: binning (división en num_bins partes).
    - Variables binarias y categóricas: proporciones de la variable target en cada categoría.

    Parámetros:
    - df: DataFrame con los datos.
    - target_col: Nombre de la variable objetivo.
    - binary_vars: Lista de variables binarias.
    - categorical_vars: Lista de variables categóricas.
    - continuous_vars: Lista de variables continuas.
    - num_bins: Número de bins para variables continuas.

    Retorno:
    - iv_df: DataFrame con los valores IV de cada variable.
    """
    iv_dict = {}

    df = df.drop(columns=['id'], axis=1)
    
    for col in df.columns:
        if col == target_col:
            continue

        temp_df = df[[col, target_col]].copy()

        # Reemplazo valores -1 con NaN para tratar datos ausentes pero NO elimino (misma lógica que gini):
        temp_df[col] = temp_df[col].replace(-1, np.nan)

        # Aplico binning solo a variables continuas (alnum_bins =10 son deciles)
        if col in continuous_vars:
            temp_df[col] = pd.qcut(temp_df[col], q=num_bins, duplicates="drop")

        # Tabla de frecuencia de eventos y no eventos
        iv_table = temp_df.groupby(col, observed=False)[target_col].agg(['count', 'sum'])
        iv_table.columns = ['Total', 'Events']
        iv_table['Non-Events'] = iv_table['Total'] - iv_table['Events']

        # Cálculo % de eventos y % de no eventos en cada grupo
        iv_table['% Events'] = iv_table['Events'] / iv_table['Events'].sum()
        iv_table['% Non-Events'] = iv_table['Non-Events'] / iv_table['Non-Events'].sum()
        iv_table['% Events'] = np.where(iv_table['% Events'] == 0, 0.0001, iv_table['% Events'])
        iv_table['% Non-Events'] = np.where(iv_table['% Non-Events'] == 0, 0.0001, iv_table['% Non-Events'])

        # WoE
        iv_table['WOE'] = np.log(iv_table['% Non-Events'] / iv_table['% Events'])

        # IV
        iv_table['IV'] = (iv_table['% Non-Events'] - iv_table['% Events']) * iv_table['WOE']
        iv_dict[col] = iv_table['IV'].sum()

    iv_df = pd.DataFrame(list(iv_dict.items()), columns=['Feature', 'Information Value (IV)'])
    iv_df = iv_df.sort_values(by='Information Value (IV)', ascending=False)

    return iv_df


def plot_iv_results(iv_df):
    """
    Visualiza el Information Value (IV) de las variables en un gráfico de barras.
    """
    iv_df = iv_df.sort_values(by="Information Value (IV)", ascending=False)

    iv_thresholds = {
        "Bajo": 0.005,
        "Medio": 0.01,
        "Alto": 0.05
    }

    plt.figure(figsize=(20, 14))
    color = (0/255, 155/255, 200/255) 

    ax = sns.barplot(y=iv_df["Feature"], x=iv_df["Information Value (IV)"], color=color)
    for label, value in iv_thresholds.items():
        plt.axvline(x=value, color="red", linestyle="dashed", linewidth=2, label=f"{label} ({value:.2f})")

    plt.xlabel("Information Value (IV)", fontsize=12)
    plt.ylabel("Feature", fontsize=12)
    plt.title("Information Value (IV) de las Variables", fontsize=14, fontweight="bold")

    plt.legend()
    plt.show()


# --------------------------------------------------
#---------EJECUCIÓN y PLOT--------------------------
# --------------------------------------------------
iv_total = iv_02(train, target, binary_vars, categorical_vars, continuous_vars)
plot_iv_results(iv_total)

# --------------------------------------------------------------
# 3. Permutation Importance ------------------------------------
# --------------------------------------------------------------

def importance_03(df):
    """
    Cálculo de la Importancia por permutación basada en resultados de RF naive.

    Parámetros:
    df (pd.DataFrame): DataFrame con variables numéricas.
    
    Retorna:
    pd.DataFrame: DataFrame con los valores de Peerm.Imp de cada variable.
    """

    # Separación de features y target
    X = df.drop(columns=['target', 'id']).replace(-1, np.nan)  # Reemplazo -1 por NaN y NO elimino
    y = df['target']

    # Defino el modelo naive sin hiperparámetros optimizados:
    model = RandomForestClassifier(
        n_estimators=20, 
        max_depth=8,  
        max_features="sqrt",  
        bootstrap=True,  
        n_jobs=-1,  
        random_state=42
    )
    model.fit(X, y)

    # Calculo la Permutation Importance:
    perm_importance = permutation_importance(
        model, X, y, 
        n_repeats=5,  
        random_state=42, 
        scoring='accuracy',
        n_jobs=-1 
    )

    perm_importance_df = pd.DataFrame({
        'Feature': X.columns, 
        'Permutation Importance': (perm_importance.importances_mean*10000) 
        # multiplico por factor 1·10^4, solo a efectos de comparación relativa
    }).sort_values(by='Permutation Importance', ascending=False)

    return perm_importance_df


def plot_permutation_importance_results(perm_importance_df):
    """
    Visualiza la Permutation Importance de las variables en un gráfico de barras.
    """
    plt.figure(figsize=(20, 14)) 
    color = (0/255, 155/255, 200/255)  

    ax = sns.barplot(y=perm_importance_df["Feature"], x=perm_importance_df["Permutation Importance"], color=color)
    plt.xlabel("Permutation Importance", fontsize=12)
    plt.ylabel("Feature", fontsize=12)
    plt.title("Permutation Importance de las Variables", fontsize=14, fontweight="bold")
    plt.show()


# --------------------------------------------------
#---------EJECUCIÓN Y PLOT--------------------------
# --------------------------------------------------
permutation_total = importance_03(train)
plot_permutation_importance_results(permutation_total)

# --------------------------------------------------------------
# 4. Variance Inflation Factor (VIF) ---------------------------
# --------------------------------------------------------------

def vif_04(df):
    """
    Calcula el Variance Inflation Factor (VIF) para detectar colinealidad entre variables continuas.
    - Elimina columnas con varianza cero para evitar errores.
    - Maneja valores nulos eliminando filas con NaN antes de calcular el VIF.

    Parámetros:
    df (pd.DataFrame): DataFrame con variables numéricas.

    Retorna:
    pd.DataFrame: DataFrame con los valores de VIF de cada variable.
    """
    # Elimino columnas constantes (varianza cero)
    df = df.loc[:, df.var() > 0]

    # Quito filas con valores n/a y control:
    df = df.replace(-1, np.nan).dropna() # En continuas, elimino N/A's, para que no afecten a la distribucioón
    if df.shape[1] == 0:
        return pd.DataFrame(columns=["Feature", "VIF"])

    # Calculo VIF
    vif_data = pd.DataFrame()
    vif_data["Feature"] = df.columns
    vif_data["VIF"] = [variance_inflation_factor(df.values, i) for i in range(df.shape[1])]

    return vif_data

def plot_vif_results(df):
    """
    Visualiza el VIF de las variables en un gráfico de barras.
    """
    plt.figure(figsize=(20, 6)) 
    color = (0/255, 155/255, 200/255)

    ax = sns.barplot(y=df["Feature"], x=df["VIF"], color=color)
    plt.xlabel("VIF", fontsize=12)
    plt.ylabel("Feature", fontsize=12)
    plt.title("VIF de las Variables", fontsize=14, fontweight="bold")
    plt.show()



# --------------------------------------------------
#---------EJECUCIÓN (solo varibles continuas) ----
# --------------------------------------------------
scaler = StandardScaler()
if continuous_vars:
    X_continuous = train[continuous_vars].copy().replace(-1, np.nan).dropna()
    
    if X_continuous.shape[1] > 1:
        X_continuous_scaled = scaler.fit_transform(X_continuous)
    else:
        X_continuous_scaled = X_continuous.values
    vif_df = vif_04(pd.DataFrame(X_continuous_scaled, columns=X_continuous.columns))
else:
    vif_df = pd.DataFrame(columns=["Feature", "VIF"])

# VIF descendente
vif_total = vif_df.sort_values(by="VIF", ascending=False).reset_index(drop=True)
vif_total

plot_vif_results(vif_total)

# --------------------------------------------------------------
# 5. Kolmogorov-Smirnov (KS Test) ------------------------------
# --------------------------------------------------------------

def ks_test(df, target, continuous_vars):
    """
    Calcula el estadístico KS para variables continuas.
    
    Parámetros:
    - df: DataFrame con los datos.
    - target: Variable objetivo binaria.
    - continuous_vars: Lista de variables continuas.
    
    Retorna:
    - DataFrame con los valores KS ordenados en orden descendente.
    """
    ks_results = []
    temp_df = df.copy().replace(-1, np.nan).dropna()  # KS no soporta NaN, y los elimino para que no afecten a la distribución.
    
    for col in continuous_vars:
        ks_stat, _ = ks_2samp(temp_df[col][temp_df[target] == 1], temp_df[col][temp_df[target] == 0])
        ks_results.append({"Feature": col, "KS": ks_stat})
    
    ks_df = pd.DataFrame(ks_results).sort_values(by="KS", ascending=False).reset_index(drop=True)

    return ks_df

def plot_ks_results(ks_df):
    """
    Visualiza el Kolmogorov-Smirnov (KS) de las variables en un gráfico de barras.
    """
    plt.figure(figsize=(20, 6))  
    color = (0/255, 155/255, 200/255) 

    ax = sns.barplot(y=ks_df["Feature"], x=ks_df["KS"], color=color)
    plt.xlabel("Kolmogorov-Smirnov (KS)", fontsize=12)
    plt.ylabel("Feature", fontsize=12)
    plt.title("Kolmogorov-Smirnov (KS) de las Variables", fontsize=14, fontweight="bold")
    plt.show()


# --------------------------------------------------
#---------EJECUCIÓN (solo variables continuas) -----
# --------------------------------------------------
ks_total=ks_test(train, target, continuous_vars)
plot_ks_results(ks_total)

# Creación de un DataFrame vacío para almacenar los resultados consolidados del análisis:
final_df = pd.DataFrame()

# Unión condicional y robusta si estos existen:
if 'gini_total' in locals():
    final_df = gini_total
if 'iv_total' in locals():
    final_df = final_df.merge(iv_total, on="Feature", how="outer") if not final_df.empty else iv_total
if 'permutation_total' in locals():
    final_df = final_df.merge(permutation_total, on="Feature", how="outer") if not final_df.empty else permutation_total
if 'vif_total' in locals():
    final_df = final_df.merge(vif_total, on="Feature", how="outer") if not final_df.empty else vif_total
if 'ks_total' in locals():
    final_df = final_df.merge(ks_total, on="Feature", how="outer") if not final_df.empty else ks_total

# Muestro:
final_df

# Definio umbrales (a efectos de viz siguiente) y no de filtrado, en función de valores obtenidos:

gini_threshold= 0.01 # es (abs(gini))
iv_threshold = 0.01 
perm_threshold = 0.01 # está · 10^4

vif_threshold = 5  
ks_threshold = 0.1

# Muestro:

def highlight_values(val, column):
    if column == 'Gini':
        return 'background-color: #c8e6c9' if abs(val) >= gini_threshold else 'background-color: #ffcc80'
    elif column == 'Information Value (IV)':
        return 'background-color: #c8e6c9' if val >= iv_threshold else 'background-color: #ffcc80'
    elif column == 'Permutation Importance':
        return 'background-color: #c8e6c9' if val >= perm_threshold else 'background-color: #ffcc80'

    elif column == 'VIF':
        return 'background-color: #c8e6c9' if val <= vif_threshold else 'background-color: #ffcc80'
    elif column == 'KS':
        return 'background-color: #c8e6c9' if val >= ks_threshold else 'background-color: #ffcc80'
    
    return ''

final_df[['Gini','Information Value (IV)','Permutation Importance', 'VIF', 'KS']] = final_df[['Gini', 'Information Value (IV)','Permutation Importance','VIF', 'KS']].round(5)

# Aplico estilos para viz:
styled_df = final_df.style.format(precision=5) \
                         .applymap(lambda val: highlight_values(val, 'Gini'), subset=['Gini']) \
                         .applymap(lambda val: highlight_values(val, 'Information Value (IV)'), subset=['Information Value (IV)']) \
                         .applymap(lambda val: highlight_values(val, 'Permutation Importance'), subset=['Permutation Importance']) \
                        #  .applymap(lambda val: highlight_values(val, 'VIF'), subset=['VIF']) \
                        #  .applymap(lambda val: highlight_values(val, 'KS'), subset=['KS'])
                        
styled_df

C:\Users\U0124476\AppData\Local\Temp\1\ipykernel_32804\1172576962.py:22: FutureWarning:

Styler.applymap has been deprecated. Use Styler.map instead.

C:\Users\U0124476\AppData\Local\Temp\1\ipykernel_32804\1172576962.py:23: FutureWarning:

Styler.applymap has been deprecated. Use Styler.map instead.

C:\Users\U0124476\AppData\Local\Temp\1\ipykernel_32804\1172576962.py:24: FutureWarning:

Styler.applymap has been deprecated. Use Styler.map instead.

# Selección final - métricas agregadas y preparación para discretización:

final_df_reduced = final_df.copy()
final_df_reduced['Sum Gini + IV'] = final_df_reduced[['Gini', 'Information Value (IV)']].abs().sum(axis=1)
final_df_reduced['Sum Gini + IV + Perm'] = final_df_reduced[['Gini', 'Information Value (IV)', 'Permutation Importance']].abs().sum(axis=1)

# Min/Max para comparabildiad a efectos de tabla visualizada:
final_df_reduced['Sum Gini + IV Norm'] = (final_df_reduced['Sum Gini + IV'] - final_df_reduced['Sum Gini + IV'].min()) / \
                                         (final_df_reduced['Sum Gini + IV'].max() - final_df_reduced['Sum Gini + IV'].min())

final_df_reduced['Sum Gini + IV + Perm Norm'] = (final_df_reduced['Sum Gini + IV + Perm'] - final_df_reduced['Sum Gini + IV + Perm'].min()) / \
                                                (final_df_reduced['Sum Gini + IV + Perm'].max() - final_df_reduced['Sum Gini + IV + Perm'].min())

# Visualización:
columns_to_display = ['Feature', 'Gini', 'Information Value (IV)', 'Permutation Importance', 'Sum Gini + IV', 'Sum Gini + IV + Perm']
final_df_filtered = final_df_reduced[columns_to_display]
final_df_filtered = final_df_filtered.sort_values(by=['Sum Gini + IV', 'Sum Gini + IV + Perm'], ascending=False)

cmap = sns.light_palette("red", as_cmap=True)
styled_df_filtered = final_df_filtered.style.format(precision=5) \
    .background_gradient(cmap=cmap, subset=['Sum Gini + IV', 'Sum Gini + IV + Perm'])

styled_df_filtered

# Observo relación entre las dos métricas agregadas generadas:

plt.figure(figsize=(20, 6))
sns.regplot(
    x=final_df_reduced['Sum Gini + IV'], 
    y=final_df_reduced['Sum Gini + IV + Perm'], 
    scatter_kws={"alpha":1}, 
    line_kws={"color": "red"}  
)

plt.title("Relación entre 'Sum Gini + IV' y 'Sum Gini + IV + Perm'")
plt.xlabel("Sum Gini + IV")
plt.ylabel("Sum Gini + IV + Perm")
plt.show()

# OTSU:

# Winsorization para mitigar outliers;
values = final_df_filtered["Sum Gini + IV"].dropna() 
values_trimmed = values[values < np.percentile(values, 95)].to_numpy()  

# Calcular el umbral de Otsu desde threshold_otsu:
otsu_threshold = threshold_otsu(values_trimmed)
print(f"Umbral de Otsu por threshold_otsu desde Skimage: {otsu_threshold}")


# Cálculo manual de Otsu en base a definición funcional (ratificación):
# ---------------------------------------------------------------------

# Binarizo en 20 bins (esto puede llevar a ligeras diferencias):
hist, bin_edges = np.histogram(values_trimmed, bins=20)
bin_mids = (bin_edges[:-1] + bin_edges[1:]) / 2

# Prob de cada clase:
w1 = np.cumsum(hist)
w2 = np.cumsum(hist[::-1])[::-1]

# mediana acumulada:
media1 = np.cumsum(hist * bin_mids) / w1
media2 = (np.cumsum((hist * bin_mids)[::-1]) / w2[::-1])[::-1]

# varianza inter-clase
var_inter = (w1[:-1] * w2[1:] * (media1[:-1] - media2[1:])**2)

# índice con máxima varianza inter-clase:
id_max_var = np.argmax(var_inter)
opt_thr = bin_mids[id_max_var]

print(f"Umbral de Otsu cuantificado manualmente: {opt_thr}")

# Visualización gráfica:
color =(0,0.5,0.7,0.2)
plt.figure(figsize=(20, 10))
plt.hist(values_trimmed, bins=20, color=color, alpha=0.2, label="Distribución de Sum Gini + IV")
plt.axvline(opt_thr, color="red", linestyle="--", linewidth=2, label=f"Umbral óptimo: {opt_thr:.5f}")
plt.xlabel("Sum Gini + IV")
plt.ylabel("Frecuencia")
plt.title("Determinación del Punto de Corte Óptimo")
plt.legend()
plt.grid(axis="y", linestyle="--", alpha=0.6)

plt.show()

Umbral de Otsu por threshold_otsu desde Skimage: 0.042794941406249995
Umbral de Otsu cuantificado manualmente: 0.04024825

# Visualización:

df = pd.DataFrame(final_df_filtered)

color_gini = "blue"
color_iv = "green"
color_perm = "purple"
color_bar = (0, 0.5, 0.7, 0.2)

plt.figure(figsize=(20, 8))
plt.plot(df["Feature"], abs(df["Gini"]), label="Gini", marker="o", color=color_gini, linestyle="-", linewidth=2)
plt.plot(df["Feature"], abs(df["Information Value (IV)"]), label="Information Value (IV)", marker="s", color=color_iv, linestyle="--", linewidth=2)
plt.plot(df["Feature"], abs(df["Permutation Importance"]), label="Permutation Importance", marker="^", color=color_perm, linestyle="-.", linewidth=2)

plt.bar(df["Feature"], df["Sum Gini + IV"], label="Sum Gini + IV", color=color_bar)
plt.axhline(y=opt_thr, color='red', linestyle='--', linewidth=2, label=f"Umbral Otsu: {opt_thr:.5f}")
plt.xlabel("Feature")
plt.ylabel("Value")
plt.title("Feature Importance Metrics")
plt.xticks(rotation=90)
plt.legend()
plt.grid(True)

plt.show()

df_final_train = final_df_filtered[final_df_filtered['Sum Gini + IV'] >= opt_thr]
df_final_train

# Extracción de la lista de valores únicos en la columna "Features" y añadir target e id, a efectos de identificación:
features_list = ["id", "target"] + df_final_train["Feature"].unique().tolist()

# Dataset final para planteamiento analítico - Modelización de target:
train_filtered = train[features_list]

train_filtered.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 595212 entries, 0 to 595211
Data columns (total 16 columns):
 #   Column         Non-Null Count   Dtype  
---  ------         --------------   -----  
 0   id             595212 non-null  int64  
 1   target         595212 non-null  int64  
 2   ps_car_13      595212 non-null  float64
 3   ps_car_12      595212 non-null  float64
 4   ps_reg_03      595212 non-null  float64
 5   ps_ind_06_bin  595212 non-null  int64  
 6   ps_ind_07_bin  595212 non-null  int64  
 7   ps_ind_17_bin  595212 non-null  int64  
 8   ps_ind_16_bin  595212 non-null  int64  
 9   ps_car_02_cat  595212 non-null  int64  
 10  ps_car_03_cat  595212 non-null  int64  
 11  ps_car_07_cat  595212 non-null  int64  
 12  ps_car_08_cat  595212 non-null  int64  
 13  ps_car_04_cat  595212 non-null  int64  
 14  ps_car_14      595212 non-null  float64
 15  ps_reg_02      595212 non-null  float64
dtypes: float64(5), int64(11)
memory usage: 72.7 MB

train_filtered.head()

# Tipología del subconjunto siguiendo mismo criterio que sobre el conjunto total:
target='target'
binary_vars, categorical_vars, continuous_vars = classify_variables(train_filtered, target)

print(f"Variables binarias: {binary_vars}\n")
print(f"Variables categóricas: {categorical_vars}\n")
print(f"Variables continuas: {continuous_vars}\n")

Variables binarias: ['ps_ind_06_bin', 'ps_ind_07_bin', 'ps_ind_17_bin', 'ps_ind_16_bin', 'ps_car_08_cat']

Variables categóricas: ['ps_car_02_cat', 'ps_car_03_cat', 'ps_car_07_cat', 'ps_car_04_cat', 'ps_reg_02']

Variables continuas: ['ps_car_13', 'ps_car_12', 'ps_reg_03', 'ps_car_14']

# Viz de variables, previa antrada a modelo:

fig, ax = plt.subplots(figsize=(16, 8))
for col in ['ps_reg_03', 'ps_car_12', 'ps_car_14', 'ps_car_13']:
    sns.kdeplot(train_filtered[col].dropna(), label=col, fill=True, alpha=0.4)

ax.set_title("Distribución de Variables Previas a Entrada al Modelo", fontsize=14)
ax.set_xlabel("Valor")
ax.set_ylabel("Densidad")
ax.legend()

plt.show()

# Normalizo con el Imputer que ya había generado para normalizar las otras cuant:
train_filtered[['ps_car_13']] = normal_dist.fit_transform(train_filtered[['ps_car_13']])

# Visualizo de nuevo:
fig, ax = plt.subplots(figsize=(16, 8))
for col in ['ps_reg_03', 'ps_car_12', 'ps_car_14', 'ps_car_13']:
    sns.kdeplot(train_filtered[col].dropna(), label=col, fill=True, alpha=0.4)

ax.set_title("Distribución de Variables Previas a Entrada al Modelo", fontsize=14)
ax.set_xlabel("Valor")
ax.set_ylabel("Densidad")
ax.legend()

plt.show()

C:\Users\U0124476\AppData\Local\Temp\1\ipykernel_32804\800433536.py:2: SettingWithCopyWarning:


A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy

X = train_filtered.drop(columns=["target", "id"])  # Quitar target e ID
y = train_filtered["target"]

# División en train_val y test (80/20) el conjunto total:
X_train_val, X_test, y_train_val, y_test = train_test_split(X, y, test_size=0.2, random_state=123, stratify=y)

# División del conjunto de entrenamiento en train y validación (80/20 de train_val) sobre este mismo:
X_train, X_val, y_train, y_val = train_test_split(X_train_val, y_train_val, test_size=0.2, random_state=123, stratify=y_train_val)

# PREPROCESAMIENTO
# --------------------------------------------------------------------------------

# Imputación de valores en categóricas con -1
imputer_cat = SimpleImputer(strategy="constant", fill_value=-1)
X_train[categorical_vars] = imputer_cat.fit_transform(X_train[categorical_vars])
X_val[categorical_vars] = imputer_cat.transform(X_val[categorical_vars])
X_test[categorical_vars] = imputer_cat.transform(X_test[categorical_vars])

# One-Hot Encoding para variables categóricas
encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_cat = encoder.fit_transform(X_train[categorical_vars])
X_val_cat = encoder.transform(X_val[categorical_vars])
X_test_cat = encoder.transform(X_test[categorical_vars])

# Variables binarias (se quedan igual)
X_train_bin = X_train[binary_vars].values
X_val_bin = X_val[binary_vars].values
X_test_bin = X_test[binary_vars].values

# Variables continuas (ya están escaladas, se dejan igual)
X_train_quant = X_train[continuous_vars].values
X_val_quant = X_val[continuous_vars].values
X_test_quant = X_test[continuous_vars].values

# Concatenación de todas las transformaciones para cada conjunto
X_train_processed = np.hstack([X_train_cat, X_train_bin, X_train_quant])
X_val_processed   = np.hstack([X_val_cat, X_val_bin, X_val_quant])
X_test_processed  = np.hstack([X_test_cat, X_test_bin, X_test_quant])

# Número de registros en cada conjunto
print("Registros en el conjunto de entrenamiento:", X_train_processed.shape[0])
print("Registros en el conjunto de validación:", X_val_processed.shape[0])
print("Registros en el conjunto de test:", X_test_processed.shape[0])

# Observación:
# Balance de clases en cada conjunto (usando los vectores originales de y)
print("\nBalance de clases en el conjunto de entrenamiento:")
print(y_train.value_counts(normalize=True))
print("\nBalance de clases en el conjunto de validación:")
print(y_val.value_counts(normalize=True))
print("\nBalance de clases en el conjunto de test:")
print(y_test.value_counts(normalize=True))

Registros en el conjunto de entrenamiento: 380935
Registros en el conjunto de validación: 95234
Registros en el conjunto de test: 119043

Balance de clases en el conjunto de entrenamiento:
target
0    0.963553
1    0.036447
Name: proportion, dtype: float64

Balance de clases en el conjunto de validación:
target
0    0.963553
1    0.036447
Name: proportion, dtype: float64

Balance de clases en el conjunto de test:
target
0    0.963551
1    0.036449
Name: proportion, dtype: float64

# Balance de las clasess a predecir por el modelo. XGBoost y LightGBM utilizarán este peso para darle más importancia a los errores en la clase minoritaria.
scale_pos_weight = y_train.value_counts()[0] / y_train.value_counts()[1]
print(scale_pos_weight)

26.4369778161913

# Definición de regresión logística. Planteamiento clásico:
def objective_logreg(trial):
    params = {
        "C": trial.suggest_float("C", 0.01, 10, log=True),
        "solver": trial.suggest_categorical("solver", ["lbfgs", "liblinear"]),
        "class_weight": "balanced",
        "max_iter": 500
    }
    model = LogisticRegression(**params)
    model.fit(X_train_processed, y_train)
    y_pred_proba = model.predict_proba(X_val_processed)[:, 1]
    return roc_auc_score(y_val, y_pred_proba)


# Definición de XGB:
def objective_xgb(trial):
    params = {
        "n_estimators": trial.suggest_int("n_estimators", 50, 500),
        "max_depth": trial.suggest_int("max_depth", 3, 12),
        "learning_rate": trial.suggest_float("learning_rate", 0.005, 0.3, log=True),
        "scale_pos_weight": scale_pos_weight,  # Ajuste para el desbalanceo
        "subsample": trial.suggest_float("subsample", 0.6, 1.0),
        "colsample_bytree": trial.suggest_float("colsample_bytree", 0.6, 1.0),
        "gamma": trial.suggest_float("gamma", 0, 5),
        "reg_alpha": trial.suggest_float("reg_alpha", 0.0, 1.0),  # Regularización L1
        "reg_lambda": trial.suggest_float("reg_lambda", 0.0, 1.0)  # Regularización L2
    }
    
    model = XGBClassifier(**params, use_label_encoder=False, eval_metric="auc")
    model.fit(
        X_train_processed, y_train,
        eval_set=[(X_val_processed, y_val)],
        verbose=False
    )
    y_pred_proba = model.predict_proba(X_val_processed)[:, 1]
    return roc_auc_score(y_val, y_pred_proba)


# Definición de LigthGBM:
def objective_lgbm(trial):
    params = {
        "num_leaves": trial.suggest_int("num_leaves", 10, 100),
        "learning_rate": trial.suggest_float("learning_rate", 0.005, 0.3, log=True),
        "n_estimators": trial.suggest_int("n_estimators", 50, 500),
        "is_unbalance": True,  # LightGBM ajusta automáticamente la ponderación de clases
        "feature_fraction": trial.suggest_float("feature_fraction", 0.6, 1.0),
        "lambda_l1": trial.suggest_float("lambda_l1", 0.0, 1.0),  # Regularización L1
        "lambda_l2": trial.suggest_float("lambda_l2", 0.0, 1.0)   # Regularización L2
    }
    
    model = LGBMClassifier(**params, objective="binary")
    model.fit(
        X_train_processed, y_train,
        eval_set=[(X_val_processed, y_val)],
        eval_metric="auc"
    )
    y_pred_proba = model.predict_proba(X_val_processed)[:, 1]
    return roc_auc_score(y_val, y_pred_proba)


# Definición de Tabnet:
def objective_tabnet(trial):
    params = {
        "n_d": trial.suggest_int("n_d", 8, 64),
        "n_a": trial.suggest_int("n_a", 8, 64),
        "n_steps": trial.suggest_int("n_steps", 3, 10),
        "gamma": trial.suggest_float("gamma", 1.0, 2.0),
        "lambda_sparse": trial.suggest_float("lambda_sparse", 0.001, 0.1),
        "momentum": trial.suggest_float("momentum", 0.02, 0.98)
    }
    
    model = TabNetClassifier(**params, verbose=0)
    model.fit(
        X_train_processed, y_train.values,
        eval_set=[(X_val_processed, y_val.values)],
        eval_metric=['auc'],
        patience=50,         
        max_epochs=1000,      
        batch_size=256,  
        virtual_batch_size=64,
        drop_last=False       
    )
    y_pred_proba = model.predict_proba(X_val_processed)[:, 1]
    return roc_auc_score(y_val, y_pred_proba)

# Versionado y accesibilidad: 
version = "tfm_rsin_v00"
version_dir = f"results/{version}"

# Creación del directorio:
os.makedirs(version_dir, exist_ok=True)

# Guardo encoder e imputer para usarlos ex-post (e.g para desplegar entorno productivo):
with open(f"{version_dir}/encoder_{version}.pkl", "wb") as f:
    pickle.dump(encoder, f)

with open(f"{version_dir}/imputer_cat_{version}.pkl", "wb") as f:
    pickle.dump(imputer_cat, f)

# EJECUCIÓN DE OPTUNA 
# --------------------------------------------------------------------------------------------

# Iniciamos servidor Optuna Dashboard en segundo plano
study_storage = f"sqlite:///{version_dir}/optuna_dashboard_{version}.db"

subprocess.Popen(["optuna-dashboard", study_storage, "--port", "8080"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(3)  # Tiempo de espera de unos segundos para que se inicie el servidor

# Función para mostrar Optuna Dashboard en el notebook:
def show_optuna_dashboard():
    display(HTML(f'<iframe src="http://localhost:8080" width="100%" height="600px"></iframe>'))

# Estudios:
n_trials = 10

study_logreg = optuna.create_study(direction="maximize", storage=study_storage, study_name=f"logreg_{version}", load_if_exists=True)
study_logreg.optimize(objective_logreg, n_trials=n_trials)

study_xgb = optuna.create_study(direction="maximize", storage=study_storage, study_name=f"xgb_{version}", load_if_exists=True)
study_xgb.optimize(objective_xgb, n_trials=n_trials)

study_lgbm = optuna.create_study(direction="maximize", storage=study_storage, study_name=f"lgbm_{version}", load_if_exists=True)
study_lgbm.optimize(objective_lgbm, n_trials=n_trials)

study_tabnet = optuna.create_study(direction="maximize", storage=study_storage, study_name=f"tabnet_{version}", load_if_exists=True)
study_tabnet.optimize(objective_tabnet, n_trials=n_trials)

# Mostramos el dashboard en local cuando se ejecuta por 1a vez:
show_optuna_dashboard()

# Viz en web cuando ya está definido el proceso:
study_storage = f"sqlite:///{version_dir}/optuna_dashboard_{version}.db"

subprocess.Popen(["optuna-dashboard", study_storage, "--port", "8080"], stdout=subprocess.DEVNULL)
time.sleep(2)
webbrowser.open("http://localhost:8080")

# El True indica que se ha aperturado correctamente en una ventana del navegador

True

# Guardado de hiperparámetros de cada estudio para posterior entrenamiento:

with open(f"{version_dir}/best_params_logreg_{version}.pkl", "wb") as f:
    pickle.dump(study_logreg.best_params, f)

with open(f"{version_dir}/best_params_xgb_{version}.pkl", "wb") as f:
    pickle.dump(study_xgb.best_params, f)

with open(f"{version_dir}/best_params_lgbm_{version}.pkl", "wb") as f:
    pickle.dump(study_lgbm.best_params, f)

with open(f"{version_dir}/best_params_tabnet_{version}.pkl", "wb") as f:
    pickle.dump(study_tabnet.best_params, f)

# Guardado de los estudios completos a parte de solo los mejores hiperparms:

with open(f"{version_dir}/study_logreg_{version}.pkl", "wb") as f:
    pickle.dump(study_logreg, f)

with open(f"{version_dir}/study_xgb_{version}.pkl", "wb") as f:
    pickle.dump(study_xgb, f)

with open(f"{version_dir}/study_lgbm_{version}.pkl", "wb") as f:
    pickle.dump(study_lgbm, f)

with open(f"{version_dir}/study_tabnet_{version}.pkl", "wb") as f:
    pickle.dump(study_tabnet, f)

# Llamada al resultado de optuna (estudios):

with open(f"{version_dir}/study_logreg_{version}.pkl", "rb") as f:
    study_logreg = pickle.load(f)

with open(f"{version_dir}/study_xgb_{version}.pkl", "rb") as f:
    study_xgb = pickle.load(f)

with open(f"{version_dir}/study_lgbm_{version}.pkl", "rb") as f:
    study_lgbm = pickle.load(f)

with open(f"{version_dir}/study_tabnet_{version}.pkl", "rb") as f:
    study_tabnet = pickle.load(f)

# Viz del proceso de Optuna, sobre las 10 iteraciones definidas:

def plot_study_history(study, name):
    values = [trial.value for trial in study.trials if trial.value is not None]
    plt.plot(values, label=name)

plt.figure(figsize=(16, 4))
plot_study_history(study_logreg, "Logistic Regression")
plot_study_history(study_xgb, "XGBoost")
plot_study_history(study_lgbm, "LightGBM")
plot_study_history(study_tabnet, "TabNet")
plt.xlabel("Iteración")
plt.ylabel("Score (e.g. AUC)")
plt.title("Historial de puntuaciones durante la optimización")
plt.legend()
plt.grid()
plt.tight_layout()

plt.show()

# Guardado en df de la información del estudio:

resumen = pd.DataFrame({
    "Modelo": ["Logistic Regression", "XGBoost", "LightGBM", "TabNet"],
    "Mejor Score": [
        study_logreg.best_value,
        study_xgb.best_value,
        study_lgbm.best_value,
        study_tabnet.best_value
    ],
    "Mejor Trial": [
        study_logreg.best_trial.number,
        study_xgb.best_trial.number,
        study_lgbm.best_trial.number,
        study_tabnet.best_trial.number
    ],
    "Nº de Trials": [
        len(study_logreg.trials),
        len(study_xgb.trials),
        len(study_lgbm.trials),
        len(study_tabnet.trials)
    ]
})

# importancia de hiperparámetros
importancias = {
    "Logistic Regression": optuna.importance.get_param_importances(study_logreg),
    "XGBoost": optuna.importance.get_param_importances(study_xgb),
    "LightGBM": optuna.importance.get_param_importances(study_lgbm),
    "TabNet": optuna.importance.get_param_importances(study_tabnet),
}

importances_df = pd.DataFrame.from_dict(importancias, orient="index").T

display(resumen)

display(importances_df)

# Llamo a los resultados para entrenamiento definitivo de modelos:

with open(f"{version_dir}/best_params_logreg_{version}.pkl", "rb") as f:
    params_logreg = pickle.load(f)

with open(f"{version_dir}/best_params_xgb_{version}.pkl", "rb") as f:
    params_xgb = pickle.load(f)

with open(f"{version_dir}/best_params_lgbm_{version}.pkl", "rb") as f:
    params_lgbm = pickle.load(f)

with open(f"{version_dir}/best_params_tabnet_{version}.pkl", "rb") as f:
    params_tabnet = pickle.load(f)

# Diccionarios de guardado de información del entrenamiento:
modelos = {}
curvas = {}

# Comprobación de parametría:
print("LR:", params_logreg)
print("XGB:", params_xgb)
print("LGBM:", params_lgbm)
print("TabNet:", params_tabnet)

LR: {'C': 5.366156675267107, 'solver': 'liblinear'}
XGB: {'n_estimators': 473, 'max_depth': 4, 'learning_rate': 0.005726464156884109, 'subsample': 0.8820362099340904, 'colsample_bytree': 0.6038723206241715, 'gamma': 1.6810668392690635, 'reg_alpha': 0.7331456904581268, 'reg_lambda': 0.5085616047004449}
LGBM: {'num_leaves': 28, 'learning_rate': 0.022649794660349016, 'n_estimators': 277, 'feature_fraction': 0.6000156786962209, 'lambda_l1': 0.5036226962512214, 'lambda_l2': 0.15331867481902328}
TabNet: {'n_d': 58, 'n_a': 64, 'n_steps': 10, 'gamma': 1.0260856760812516, 'lambda_sparse': 0.0030223562078505292, 'momentum': 0.5236943812424828}

# Regresión logística:

params_logreg.update({"class_weight": "balanced", "max_iter": 500})
model_logreg = LogisticRegression(**params_logreg)
model_logreg.fit(X_train_processed, y_train)
modelos["LogisticRegression"] = model_logreg

# XGBoost

params_xgb.update({"scale_pos_weight": scale_pos_weight})
results_xgb = {}
model_xgb = XGBClassifier(**params_xgb, use_label_encoder=False, eval_metric="auc")
model_xgb.fit(
    X_train_processed, y_train,
    eval_set=[(X_train_processed, y_train), (X_val_processed, y_val)],
    verbose=False
)

results_xgb = model_xgb.evals_result()
modelos["XGBoost"] = model_xgb
curvas["XGBoost"] = results_xgb

c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[15:35:59] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.

# LightGBM

params_lgbm.update({"is_unbalance": True})
results_lgbm = {} 
model_lgbm = LGBMClassifier(**params_lgbm, objective="binary")
model_lgbm.fit(
    X_train_processed, y_train,
    eval_set=[(X_train_processed, y_train), (X_val_processed, y_val)],
    eval_metric="auc"
)

results_lgbm = model_lgbm.evals_result_
modelos["LightGBM"] = model_lgbm
curvas["LightGBM"] = results_lgbm

[LightGBM] [Warning] feature_fraction is set=0.6000156786962209, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.6000156786962209
[LightGBM] [Warning] lambda_l1 is set=0.5036226962512214, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.5036226962512214
[LightGBM] [Warning] lambda_l2 is set=0.15331867481902328, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.15331867481902328
[LightGBM] [Warning] feature_fraction is set=0.6000156786962209, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.6000156786962209
[LightGBM] [Warning] lambda_l1 is set=0.5036226962512214, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.5036226962512214
[LightGBM] [Warning] lambda_l2 is set=0.15331867481902328, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.15331867481902328
[LightGBM] [Info] Number of positive: 13884, number of negative: 367051
[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.016348 seconds.
You can set `force_row_wise=true` to remove the overhead.
And if memory is not enough, you can set `force_col_wise=true`.
[LightGBM] [Info] Total Bins 970
[LightGBM] [Info] Number of data points in the train set: 380935, number of used features: 46
[LightGBM] [Warning] feature_fraction is set=0.6000156786962209, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.6000156786962209
[LightGBM] [Warning] lambda_l1 is set=0.5036226962512214, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.5036226962512214
[LightGBM] [Warning] lambda_l2 is set=0.15331867481902328, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.15331867481902328
[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.036447 -> initscore=-3.274764
[LightGBM] [Info] Start training from score -3.274764

# TabNet
model_tabnet = TabNetClassifier(**params_tabnet, verbose=0)
model_tabnet.fit(
    X_train_processed, y_train.values,
    eval_set=[(X_train_processed, y_train.values), (X_val_processed, y_val.values)],
    eval_metric=['auc'],
    patience=10,
    max_epochs=10,
    batch_size=128,
    virtual_batch_size=32,
    drop_last=False
)

modelos["TabNet"] = model_tabnet
curvas["TabNet"] = {
    "train_auc": model_tabnet.history['val_0_auc'],
    "valid_auc": model_tabnet.history['val_1_auc']}

Stop training because you reached max_epochs = 10 with best_epoch = 3 and best_val_1_auc = 0.57215

c:\Program Files\Python311\Lib\site-packages\pytorch_tabnet\callbacks.py:172: UserWarning:

Best weights from best epoch are automatically used!

# Inspecciono artefacto Curvas:

for modelo, contenido in curvas.items():
    print(f"\n Modelo: {modelo}")
    if isinstance(contenido, dict):
        for clave, valor in contenido.items():
            if isinstance(valor, dict):
                print(f"  Subclave: {clave} --> Keys internas: {list(valor.keys())}")
            elif isinstance(valor, list):
                print(f"  {clave}: Lista de longitud {len(valor)} (valores tipo: {type(valor[0])})")
            else:
                print(f" {clave}: {type(valor)}")
    else:
        print(f"  Contenido directo: {type(contenido)}")

 Modelo: XGBoost
  Subclave: validation_0 --> Keys internas: ['auc']
  Subclave: validation_1 --> Keys internas: ['auc']

 Modelo: LightGBM
  Subclave: training --> Keys internas: ['auc', 'binary_logloss']
  Subclave: valid_1 --> Keys internas: ['auc', 'binary_logloss']

 Modelo: TabNet
  train_auc: Lista de longitud 10 (valores tipo: <class 'numpy.float64'>)
  valid_auc: Lista de longitud 10 (valores tipo: <class 'numpy.float64'>)

# Inspecciono artefacto Modelos:

for modelo, contenido in modelos.items():
    print(f"\nModelo: {modelo}")
    if isinstance(contenido, dict):
        for clave, valor in contenido.items():
            if isinstance(valor, dict):
                print(f"  Subclave: {clave} --> Keys internas: {list(valor.keys())}")
            elif isinstance(valor, list):
                print(f"  {clave}: Lista de longitud {len(valor)} (valores tipo: {type(valor[0])})")
            else:
                print(f" {clave}: {type(valor)}")
    else:
        print(f"  Contenido directo: {type(contenido)}")

Modelo: LogisticRegression
  Contenido directo: <class 'sklearn.linear_model._logistic.LogisticRegression'>

Modelo: XGBoost
  Contenido directo: <class 'xgboost.sklearn.XGBClassifier'>

Modelo: LightGBM
  Contenido directo: <class 'lightgbm.sklearn.LGBMClassifier'>

Modelo: TabNet
  Contenido directo: <class 'pytorch_tabnet.tab_model.TabNetClassifier'>

# Visualización de las curvas de validación de los modelos basados en ensemble (más de 200 iteraciones de entrenamiento):

plt.figure(figsize=(12, 7))
plt.title("Curvas AUC de Validación por Modelo", fontsize=16)
plt.xlabel("Iteración / Época", fontsize=12)
plt.ylabel("AUC en Validación", fontsize=12)
plt.grid(True, linestyle='--', alpha=0.5)

colores = {
    "XGBoost": "#1f77b4",
    "LightGBM": "#17becf",
    "TabNet": "#08306b"
}

for modelo in curvas:
    if modelo == "XGBoost":
        aucs = curvas[modelo]["validation_1"]["auc"]
    elif modelo == "LightGBM":
        aucs = curvas[modelo]["valid_1"]["auc"]
    else:
        continue

    x = list(range(len(aucs)))
    color = colores.get(modelo, "blue")
    plt.plot(x, aucs, label=f"{modelo}", linewidth=2.5, color=color)
    max_idx = int(np.argmax(aucs))
    max_val = aucs[max_idx]
    plt.scatter(max_idx, max_val, color=color, edgecolor='white', zorder=5, s=80)

plt.legend(title="Modelos", fontsize=11, title_fontsize=12, loc="lower right")
plt.tight_layout()
plt.show()

# Evaluación de las métricas sobre el conjunto de test:

metricas = {}

for nombre, modelo in modelos.items():
    try:
        if nombre == "TabNet":
            y_prob = modelo.predict_proba(X_test_processed)[:, 1]
            y_pred = modelo.predict(X_test_processed).ravel()
        else:
            y_prob = modelo.predict_proba(X_test_processed)[:, 1]
            y_pred = modelo.predict(X_test_processed)

        metricas[nombre] = {
            "ROC-AUC": roc_auc_score(y_test, y_prob),
            "PR-AUC": average_precision_score(y_test, y_prob),
            "Recall": recall_score(y_test, y_pred),
            "F1-score": f1_score(y_test, y_pred),
            "Precision": precision_score(y_test, y_pred),
            "Accuracy": accuracy_score(y_test, y_pred)
        }
        
    except Exception as e:
        print(f"Error al evaluar {nombre}: {e}")

df_metricas = pd.DataFrame(metricas).T.sort_values(by="ROC-AUC", ascending=False).round(4)
print("\n Métricas en el conjunto de test:")
df_metricas

[LightGBM] [Warning] feature_fraction is set=0.6000156786962209, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.6000156786962209
[LightGBM] [Warning] lambda_l1 is set=0.5036226962512214, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.5036226962512214
[LightGBM] [Warning] lambda_l2 is set=0.15331867481902328, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.15331867481902328
[LightGBM] [Warning] feature_fraction is set=0.6000156786962209, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.6000156786962209
[LightGBM] [Warning] lambda_l1 is set=0.5036226962512214, reg_alpha=0.0 will be ignored. Current value: lambda_l1=0.5036226962512214
[LightGBM] [Warning] lambda_l2 is set=0.15331867481902328, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.15331867481902328

 Métricas en el conjunto de test:

# GUARDADO DE MODELOS

for nombre, modelo in modelos.items():
    with open(f"{version_dir}/modelo_trained_{nombre}_{version}.pkl", "wb") as f:
        pickle.dump(modelo, f)

print(f"Modelos guardados correctamente en '{version_dir}' con sufijo de versión.")

Modelos guardados correctamente en 'results/tfm_rsin_v00' con sufijo de versión.

mejor_modelo_nombre = df_metricas.index[0]
mejor_modelo = modelos[mejor_modelo_nombre]
print(f"\n Mejor modelo en términos relativos al resto: {mejor_modelo_nombre}")

 Mejor modelo en términos relativos al resto: XGBoost

# Predicciones de probabilidad:
y_prob_mejor = mejor_modelo.predict_proba(X_test_processed)[:, 1]

# Cutoffs a evaluar:
cutoffs = np.round(np.arange(0.0, 1.0, 0.1), 2)

# viz:
fig, axs = plt.subplots(2, 5, figsize=(22, 10))
axs = axs.flatten()

for i, cutoff in enumerate(cutoffs):
    y_pred_cutoff = (y_prob_mejor >= cutoff).astype(int)
    cm = confusion_matrix(y_test, y_pred_cutoff)

    disp = ConfusionMatrixDisplay(confusion_matrix=cm)
    disp.plot(ax=axs[i], cmap='Blues', colorbar=False)
    axs[i].set_title(f"Cutoff = {cutoff}", fontsize=12)
    axs[i].grid(False)

plt.suptitle(f"Matrices de Confusión del Modelo Óptimo: {mejor_modelo_nombre}", fontsize=18, y=1.02)
plt.tight_layout()
plt.show()

cutoffs = np.round(np.arange(0.0, 1.0, 0.1), 2)
tns, fps, fns, tps = [], [], [], []

# Cálculo de la matriz de confusión para cada cutoff
for cutoff in cutoffs:
    y_pred_cutoff = (y_prob_mejor >= cutoff).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_test, y_pred_cutoff).ravel()
    tns.append(tn)
    fps.append(fp)
    fns.append(fn)
    tps.append(tp)
fig, ax1 = plt.subplots(figsize=(12, 6))

# Eje para TN y FP:
ax1.plot(cutoffs, tns, marker='o', label="True Negatives (TN)")
ax1.plot(cutoffs, fps, marker='o', label="False Positives (FP)")
ax1.set_xlabel("Cutoff", fontsize=12)
ax1.set_ylabel("TN / FP", fontsize=12)
ax1.tick_params(axis='y')
ax1.grid(True, linestyle='--', alpha=0.5)

# Eje para FN y TP:
ax2 = ax1.twinx()
ax2.plot(cutoffs, fns, 'g--o', label="False Negatives (FN)")
ax2.plot(cutoffs, tps, 'r--o', label="True Positives (TP)")
ax2.set_ylabel("FN / TP", fontsize=12)
ax2.tick_params(axis='y')

# Unión de ambos ejes
lines_1, labels_1 = ax1.get_legend_handles_labels()
lines_2, labels_2 = ax2.get_legend_handles_labels()
ax1.legend(lines_1 + lines_2, labels_1 + labels_2, loc='center right')

plt.title(f"Evolución de la Matriz de Confusión - {mejor_modelo_nombre}", fontsize=16)
plt.xticks(cutoffs)
plt.tight_layout()

plt.show()

# Cutoffs a evaluar
cutoffs = np.round(np.arange(0.0, 1.0, 0.1), 2)
precisions, recalls, f1s, accuracies = [], [], [], []
for cutoff in cutoffs:
    y_pred_cutoff = (y_prob_mejor >= cutoff).astype(int)
    precisions.append(precision_score(y_test, y_pred_cutoff, zero_division=0))
    recalls.append(recall_score(y_test, y_pred_cutoff, zero_division=0))
    f1s.append(f1_score(y_test, y_pred_cutoff, zero_division=0))
    accuracies.append(accuracy_score(y_test, y_pred_cutoff))

plt.figure(figsize=(12, 6))
plt.plot(cutoffs, precisions, marker='o', label="Precision")
plt.plot(cutoffs, recalls, marker='o', label="Recall")
plt.plot(cutoffs, f1s, marker='o', label="F1-score")
plt.plot(cutoffs, accuracies, marker='o', label="Accuracy")
plt.title(f"Evolución de Métricas - {mejor_modelo_nombre}", fontsize=16)
plt.xlabel("Cutoff", fontsize=12)
plt.ylabel("Valor de la Métrica", fontsize=12)
plt.xticks(cutoffs)
plt.grid(True, linestyle='--', alpha=0.5)
plt.ylim(0, 1.05)
plt.legend()
plt.tight_layout()

plt.show()

# Calibrador con regresión isotónica y clase CalibratedClassifierCV:
calibrador = CalibratedClassifierCV(
    estimator=mejor_modelo,
    method='isotonic',
    cv=StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
)

# Entrenamiento sobre conjunto de entrenamiento:
calibrador.fit(X_train_processed, y_train)

# Probabilidades sobre test:
y_prob_original = mejor_modelo.predict_proba(X_test_processed)[:, 1]
y_prob_calibrado = calibrador.predict_proba(X_test_processed)[:, 1]

c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[17:22:13] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.


c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[17:22:20] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.


c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[17:22:28] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.


c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[17:22:35] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.


c:\Program Files\Python311\Lib\site-packages\xgboost\core.py:158: UserWarning:

[17:22:42] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-0c55ff5f71b100e98-1\xgboost\xgboost-ci-windows\src\learner.cc:740: 
Parameters: { "use_label_encoder" } are not used.

# Calibración sobre 10 bins:
prob_true_orig, prob_pred_orig = calibration_curve(y_test, y_prob_original, n_bins=10, strategy='quantile')
prob_true_cal, prob_pred_cal = calibration_curve(y_test, y_prob_calibrado, n_bins=10, strategy='quantile')

fig = plt.figure(figsize=(16, 10))
gs = fig.add_gridspec(2, 1, height_ratios=[2.5, 1], hspace=0.3)

# Curva:
ax0 = fig.add_subplot(gs[0])
ax0.plot([0, 1], [0, 1], 'k--', label='Calibración perfecta')
ax0.plot(prob_pred_orig, prob_true_orig, 'o--', label='Original', color='steelblue')
ax0.plot(prob_pred_cal, prob_true_cal, 'o-', label='Calibrado (Isotonic)', color='darkorange')
ax0.set_title(f"Curva de Calibración - {mejor_modelo_nombre}", fontsize=14)
ax0.set_xlabel("Probabilidad predicha")
ax0.set_ylabel("Proporción real de positivos")
ax0.set_xlim([0, 1])
ax0.set_ylim([0, 1])
ax0.grid(True, linestyle='--', alpha=0.6)
ax0.legend(loc="upper left")

ax1 = fig.add_subplot(gs[1])
sns.histplot(y_prob_original, bins=20, label='Original', color='steelblue', alpha=0.5)
sns.histplot(y_prob_calibrado, bins=20, label='Calibrado', color='darkorange', alpha=0.5)
ax1.set_xlabel("Probabilidad predicha")
ax1.set_ylabel("Frecuencia")
ax1.set_xlim([0, 1])
ax1.legend()
ax1.grid(True, linestyle='--', alpha=0.4)

plt.tight_layout()

plt.show()

C:\Users\U0124476\AppData\Local\Temp\1\ipykernel_32804\2234182741.py:30: UserWarning:

This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.

# Brier Score como métrica para conocer que se ha calibrado:
brier_original = brier_score_loss(y_test, y_prob_original)
brier_calibrated = brier_score_loss(y_test, y_prob_calibrado)

print(f"Brier Score (original): {brier_original:.4f}")
print(f"Brier Score (calibrado): {brier_calibrated:.4f}")

Brier Score (original): 0.2389
Brier Score (calibrado): 0.0349

y_test_array = np.array(y_test)
idx_y0 = np.where(y_test_array == 0)[0][0]  # Primer ejemplo clase 0
idx_y1 = np.where(y_test_array == 1)[0][0]  # Primer ejemplo clase 1

# Probabilidades predichas para ambos casos:
prob_orig_y0 = mejor_modelo.predict_proba(X_test_processed[idx_y0:idx_y0+1])[0, 1]
prob_calib_y0 = calibrador.predict_proba(X_test_processed[idx_y0:idx_y0+1])[0, 1]

prob_orig_y1 = mejor_modelo.predict_proba(X_test_processed[idx_y1:idx_y1+1])[0, 1]
prob_calib_y1 = calibrador.predict_proba(X_test_processed[idx_y1:idx_y1+1])[0, 1]

print(f"-Cliente sin siniestro (y=0) — riesgo original: {prob_orig_y0:.4f}, calibrado: {prob_calib_y0:.4f}")
print(f"-Cliente con siniestro (y=1) — riesgo original: {prob_orig_y1:.4f}, calibrado: {prob_calib_y1:.4f}")

-Cliente sin siniestro (y=0) — riesgo original: 0.4792, calibrado: 0.0345
-Cliente con siniestro (y=1) — riesgo original: 0.3544, calibrado: 0.0162

# DataFrame con nombres de columnas (lo necesitamos para LIME y SHAP):

# Obtenemos nombres de columnas del One-Hot Encoding aplicado:
cat_columns_encoded = encoder.get_feature_names_out(categorical_vars)

# Concatenamos todos los nombres (en orden: categóricas, binarias, cuantitativas)
column_names = np.concatenate([cat_columns_encoded, binary_vars, continuous_vars])

# Creamos el DataFrame con nombres reales
X_test_df = pd.DataFrame(X_test_processed, columns=column_names)

print("Columnas reales recuperadas:")
print(X_test_df.columns[:10])
print(X_test_df)

Columnas reales recuperadas:
Index(['ps_car_02_cat_-1.0', 'ps_car_02_cat_0.0', 'ps_car_02_cat_1.0',
       'ps_car_03_cat_-1.0', 'ps_car_03_cat_0.0', 'ps_car_03_cat_1.0',
       'ps_car_07_cat_-1.0', 'ps_car_07_cat_0.0', 'ps_car_07_cat_1.0',
       'ps_car_04_cat_0.0'],
      dtype='object')
        ps_car_02_cat_-1.0  ps_car_02_cat_0.0  ps_car_02_cat_1.0  \
0                      0.0                0.0                1.0   
1                      0.0                0.0                1.0   
2                      0.0                1.0                0.0   
3                      0.0                0.0                1.0   
4                      0.0                1.0                0.0   
...                    ...                ...                ...   
119038                 0.0                0.0                1.0   
119039                 0.0                0.0                1.0   
119040                 0.0                0.0                1.0   
119041                 0.0                0.0                1.0   
119042                 0.0                0.0                1.0   

        ps_car_03_cat_-1.0  ps_car_03_cat_0.0  ps_car_03_cat_1.0  \
0                      1.0                0.0                0.0   
1                      1.0                0.0                0.0   
2                      1.0                0.0                0.0   
3                      1.0                0.0                0.0   
4                      0.0                0.0                1.0   
...                    ...                ...                ...   
119038                 1.0                0.0                0.0   
119039                 1.0                0.0                0.0   
119040                 1.0                0.0                0.0   
119041                 1.0                0.0                0.0   
119042                 1.0                0.0                0.0   

        ps_car_07_cat_-1.0  ps_car_07_cat_0.0  ps_car_07_cat_1.0  \
0                      0.0                0.0                1.0   
1                      0.0                0.0                1.0   
2                      0.0                0.0                1.0   
3                      0.0                0.0                1.0   
4                      0.0                0.0                1.0   
...                    ...                ...                ...   
119038                 0.0                0.0                1.0   
119039                 0.0                0.0                1.0   
119040                 0.0                0.0                1.0   
119041                 0.0                0.0                1.0   
119042                 0.0                0.0                1.0   

        ps_car_04_cat_0.0  ...  ps_reg_02_1.8  ps_ind_06_bin  ps_ind_07_bin  \
0                     1.0  ...            0.0            0.0            0.0   
1                     1.0  ...            0.0            1.0            0.0   
2                     0.0  ...            0.0            1.0            0.0   
3                     1.0  ...            0.0            1.0            0.0   
4                     1.0  ...            0.0            0.0            1.0   
...                   ...  ...            ...            ...            ...   
119038                0.0  ...            0.0            0.0            0.0   
119039                1.0  ...            0.0            0.0            0.0   
119040                1.0  ...            0.0            0.0            1.0   
119041                1.0  ...            0.0            1.0            0.0   
119042                1.0  ...            0.0            0.0            0.0   

        ps_ind_17_bin  ps_ind_16_bin  ps_car_08_cat  ps_car_13  ps_car_12  \
0                 0.0            1.0            1.0  -0.305634   0.404717   
1                 0.0            0.0            0.0   0.925573   0.404717   
2                 0.0            0.0            1.0   0.737699   1.331018   
3                 0.0            0.0            1.0  -0.568187  -0.868016   
4                 1.0            0.0            1.0   1.298715   0.880888   
...               ...            ...            ...        ...        ...   
119038            0.0            1.0            1.0   0.980217   1.331018   
119039            0.0            1.0            0.0   0.185329  -0.868016   
119040            0.0            0.0            0.0   0.378881  -0.868016   
119041            0.0            1.0            1.0   0.111294   0.404717   
119042            0.0            1.0            1.0  -1.718987   1.625274   

        ps_reg_03  ps_car_14  
0        0.658043   0.695908  
1        0.436240   0.349483  
2        1.272016   1.401177  
3        1.284480   0.132113  
4        0.010037   0.218773  
...           ...        ...  
119038   1.588775   1.164890  
119039  -1.040090  -0.167640  
119040   1.087000  -0.248427  
119041  -0.548643   0.593940  
119042   1.480619   1.247362  

[119043 rows x 47 columns]

# Explicabilidad local con Lime sobre una observación:

# Selección del primer ID (cliente) del dataset por trazabilidad (evitar la marcación con randint, si bien esta sería de la siguiente manera): 
# i = np.random.randint(0, len(X_test_processed))

i = 0

explainer_lime = lime.lime_tabular.LimeTabularExplainer(
    training_data=X_test_processed,
    feature_names=X_test_df.columns.tolist(),
    class_names=['No', 'Sí'],
    mode='classification'
)

exp = explainer_lime.explain_instance(
    data_row=X_test_processed[i],
    predict_fn=mejor_modelo.predict_proba
)

exp.show_in_notebook(show_table=True)

# Muestreo para X test:
X_sample = X_test_df.sample(100, random_state=42)  
# SHAP es caro computacionalmente, por lo que visualizamos su carácter global sobre una muestra aleatoria de 100 obs.

# Wrapper de predicción
def predict_fn(X):
    return mejor_modelo.predict_proba(X)[:, 1]

# Explainer y obtención de SHAP Values:
explainer = shap.Explainer(predict_fn, X_sample)
shap_values = explainer(X_sample)

# Explicabilidad local sobre el primero:
shap.plots.waterfall(shap_values[0])

PermutationExplainer explainer: 101it [00:18,  3.74it/s]

shap.plots.beeswarm(shap_values)

shap.plots.bar(shap_values)

# Obtengo una lista de las top n = 5:
mean_abs_shap = np.abs(shap_values.values).mean(axis=0)
top_indices = np.argsort(mean_abs_shap)[::-1][:5]

top_vars = X_sample.columns[top_indices].tolist()

print("top_vars = [")
for var in top_vars:
    print(f"    '{var}',")
print("]")

top_vars = [
    'ps_car_13',
    'ps_reg_03',
    'ps_ind_17_bin',
    'ps_ind_06_bin',
    'ps_ind_16_bin',
]

# PDP sobre las 5 variables de SHAP global:

columnas_disponibles = [col for col in top_vars if col in X_test_df.columns]
n_features = len(columnas_disponibles)
n_cols = 5
n_rows = math.ceil(n_features / n_cols)

fig, ax = plt.subplots(n_rows, n_cols, figsize=(n_cols * 5, n_rows * 4))

display = PartialDependenceDisplay.from_estimator(
    mejor_modelo,
    X_test_processed,
    features=columnas_disponibles,
    feature_names=X_test_df.columns,
    kind='average',
    ax=ax.ravel().tolist()
)

fig.suptitle("Partial Dependence Plots - Top SHAP Features", fontsize=18)
plt.tight_layout(rect=[0, 0, 1, 0.96])

plt.show()

ml_scoring_api/
├── config.py
│   # Contiene configuraciones generales del entorno (dev, prod, test), paths de modelos, logging, flags, etc...
│
├── scoring_pipeline.py
│   # Función principal de predicción, reutiliza todo el preprocesamiento realizado en el entrenamiento:
│   import [...]
│   
│   # Carga de objetos persistidos
│   modelo_final = joblib.load("model/modelo_XGBoost.pkl")
│   encoder = joblib.load("model/encoder.pkl")
│   imputer_cat = joblib.load("model/imputer_cat.pkl")
│   from variables import categorical_vars, binary_vars, continuous_vars
│
│   def predecir(input_df):
│       [... DETALLE TEÓRICO ABAJO]
│
├── api/
│   ├── main.py
│   │   # API REST con FastAPI. Expone un endpoint /predict que recibe JSON y devuelve predicción
│   │   from fastapi import FastAPI
│   │   from pydantic import BaseModel
│   │   import pandas as pd
│   │   from scoring_pipeline import predecir
│   │
│   │   app = FastAPI()
│   │
│   │   class InputData(BaseModel):
│   │       features: dict
│   │
│   │   @app.post("/predict")
│   │   def predict(data: InputData):
│   │       df = pd.DataFrame([data.features])
│   │       proba = predecir(df)
│   │       return {"probabilidad": float(proba[0])}
│   │
│   └── schemas.py
│       # Validación de entrada con Pydantic
│       from pydantic import BaseModel
│       from typing import Dict
│       
│       class InputSchema(BaseModel):
│           features: Dict[str, float]
│
├── streamlit_dashboard/
│   └── app.py
│       # Interfaz visual con Streamlit que permita la subida de un CSV o introducir valores manuales para pred.
│       import streamlit as st
│       import pandas as pd
│       from scoring_pipeline import predecir
│
│       st.title("Scoring de Riesgo de Siniestralidad")
│       uploaded_file = st.file_uploader("Sube un archivo CSV")
│
│       if uploaded_file:
│           df = pd.read_csv(uploaded_file)
│           proba = predecir(df)
│           st.write("Probabilidad de siniestro:", proba)
│
├── model/
│   ├── modelo_XGBoost.pkl
│   ├── encoder.pkl
│   └── imputer_cat.pkl
│
├── variables.py
│   # Variables usadas en todo el pipeline: categóricas, binarias, continuas
│   categorical_vars = [...] 
│   binary_vars = [...]
│   continuous_vars = [...]
│
├── Dockerfile
│   # Imagen contenedora del API para correr en producción
│   # FROM python:3.11
│   # COPY . /app
│   # WORKDIR /app
│   # RUN pip install -r requirements.txt
│   # CMD ["uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "8080"]
│
├── requirements.txt
│   # Lista de librerías necesarias para reproducir el entorno
│   # xgboost, pandas, numpy, fastapi, streamlit, joblib, uvicorn
│
└── README.md
    # Instrucciones de despliegue, endpoints disponibles, uso en Streamlit y arquitectura general

# scoring_pipeline.py
def predecir(input_df, modelo_final, encoder, imputer_cat, binary_vars, continuous_vars, categorical_vars):
    
    """
    Aplica el preprocesamiento y devuelve la probabilidad de siniestralidad.

    Parameters:
    - input_df: DataFrame de entrada (1 o varios registros).
    - modelo_final: Modelo entrenado (XGBoost).
    - encoder: OneHotEncoder fitted.
    - imputer_cat: Imputador categórico fitted.
    - binary_vars, continuous_vars, categorical_vars: listas de variables según tipo.

    Returns:
    - np.array: Probabilidades predichas.

    """

    # Validación de columnas mínimas necesarias
    columnas_requeridas = binary_vars + continuous_vars + categorical_vars
    missing_cols = [col for col in columnas_requeridas if col not in input_df.columns]
    if missing_cols:
        raise ValueError(f"Faltan columnas en el input: {missing_cols}")

    # Imputación y transformación
    X_cat = imputer_cat.transform(input_df[categorical_vars])
    X_cat_encoded = encoder.transform(X_cat)
    X_bin = input_df[binary_vars].values
    X_quant = input_df[continuous_vars].values

    # Concatenar todas las variables preprocesadas
    X_processed = np.hstack([X_cat_encoded, X_bin, X_quant])

    # Predicción
    probas = modelo_final.predict_proba(X_processed)[:, 1]
    return probas

# pip install notebook
!jupyter nbconvert --to html tesis_001-CXB0010513-v01.ipynb

Método	Ventajas	Desventajas
Media (mean)	Fácil de calcular, útil si la variable sigue distribución normal	Muy sensible a outliers y a distribuciones asimétricas
Mediana (median) SELECCIONADA	Robusta ante outliers y asimetría; conserva representatividad central	Puede ignorar información si la variable tiene estructura multimodal
KNN Imputation	Aprovecha la correlación entre variables; imputación más precisa	Costoso computacionalmente y sensible al escalado y ruido
Interpolación temporal (ffill/bfill)	Mantiene secuencia y dinámica temporal	Inaplicable en datos no ordenados temporalmente

Valor Gini	Interpretación
0.00 - 0.10	Sin capacidad predictiva
0.10 - 0.30	Baja capacidad predictiva
0.30 - 0.50	Buena capacidad predictiva
0.50 - 0.70	Muy buena capacidad predictiva
0.70 - 1.00	Excelente capacidad predictiva

Valor IV	Interpretación
IV < 0.02	No informativa
0.02 < IV < 0.1	Débilmente predictiva
0.1 < IV < 0.3	Moderadamente predictiva
IV > 0.3	Altamente predictiva

Valor VIF	Interpretación
VIF < 5	Multicolinealidad baja
5 ≤ VIF < 10	Multicolinealidad moderada
VIF ≥ 10	Multicolinealidad alta (problema grave)

	Feature	Gini	Information Value (IV)	Permutation Importance	Sum Gini + IV	Sum Gini + IV + Perm
33	ps_car_13	0.15309	0.07207	0.10080	0.22516	0.32596
32	ps_car_12	0.11031	0.03995	0.05712	0.15026	0.20738
56	ps_reg_03	0.09806	0.03917	0.04368	0.13723	0.18091
41	ps_ind_06_bin	-0.08869	0.03459	0.06720	0.12328	0.19048
42	ps_ind_07_bin	0.07979	0.03082	0.08736	0.11061	0.19797
52	ps_ind_17_bin	0.06450	0.03289	0.11761	0.09739	0.21500
51	ps_ind_16_bin	-0.07018	0.02113	0.08400	0.09131	0.17531
21	ps_car_02_cat	-0.06323	0.02523	-0.00336	0.08846	0.09182
22	ps_car_03_cat	0.06276	0.01027	0.11425	0.07303	0.18728
26	ps_car_07_cat	-0.04448	0.00958	0.14449	0.05406	0.19855
27	ps_car_08_cat	-0.04057	0.01088	0.00336	0.05145	0.05481
23	ps_car_04_cat	0.00791	0.03496	0.08400	0.04287	0.12687
34	ps_car_14	0.02395	0.01879	0.02688	0.04274	0.06962
55	ps_reg_02	0.00063	0.04186	0.04032	0.04249	0.08281
40	ps_ind_05_cat	0.00870	0.03000	0.33265	0.03870	0.37135
20	ps_car_01_cat	-0.00032	0.03670	0.23521	0.03702	0.27223
25	ps_car_06_cat	0.00096	0.03382	0.02352	0.03478	0.05830
24	ps_car_05_cat	0.03309	0.00002	0.01008	0.03311	0.04319
31	ps_car_11_cat	0.02483	0.00639	0.09408	0.03122	0.12530
35	ps_car_15	0.00060	0.03006	0.01008	0.03066	0.04074
43	ps_ind_08_bin	0.02597	0.00466	0.05040	0.03063	0.08103
38	ps_ind_03	-0.00178	0.02880	0.06048	0.03058	0.09106
39	ps_ind_04_cat	0.02607	0.00291	0.36962	0.02898	0.39860
54	ps_reg_01	-0.00032	0.02400	0.05040	0.02432	0.07472
28	ps_car_09_cat	0.00685	0.01679	0.01680	0.02364	0.04044
44	ps_ind_09_bin	-0.01708	0.00200	0.02352	0.01908	0.04260
30	ps_car_11	-0.00440	0.01275	0.00000	0.01715	0.01715
50	ps_ind_15	-0.00074	0.01612	0.04032	0.01686	0.05718
36	ps_ind_01	0.00414	0.01177	0.00336	0.01591	0.01927
53	ps_ind_18_bin	0.00876	0.00058	0.00000	0.00934	0.00934
37	ps_ind_02_cat	0.00447	0.00108	0.23521	0.00555	0.24076
47	ps_ind_12_bin	0.00403	0.00147	0.00000	0.00550	0.00550
18	ps_calc_19_bin	-0.00444	0.00009	0.00000	0.00453	0.00453
9	ps_calc_10	0.00345	0.00046	0.02016	0.00391	0.02407
13	ps_calc_14	0.00291	0.00032	0.00336	0.00323	0.00659
49	ps_ind_14	0.00103	0.00146	0.00000	0.00249	0.00249
19	ps_calc_20_bin	-0.00206	0.00003	0.00000	0.00209	0.00209
15	ps_calc_16_bin	0.00161	0.00001	0.00000	0.00162	0.00162
10	ps_calc_11	-0.00000	0.00139	0.02352	0.00139	0.02491
17	ps_calc_18_bin	0.00133	0.00001	0.01344	0.00134	0.01478
1	ps_calc_02	0.00047	0.00049	0.01344	0.00096	0.01440
5	ps_calc_06	0.00000	0.00095	0.02688	0.00095	0.02783
14	ps_calc_15_bin	-0.00086	0.00001	0.00000	0.00087	0.00087
2	ps_calc_03	0.00044	0.00036	0.01008	0.00080	0.01088
11	ps_calc_12	-0.00021	0.00058	0.00672	0.00079	0.00751
0	ps_calc_01	0.00010	0.00068	0.00672	0.00078	0.00750
48	ps_ind_13_bin	0.00040	0.00015	0.00000	0.00055	0.00055
46	ps_ind_11_bin	0.00044	0.00010	0.00000	0.00054	0.00054
6	ps_calc_07	0.00001	0.00051	0.01344	0.00052	0.01396
16	ps_calc_17_bin	-0.00045	0.00000	0.00672	0.00045	0.00717
7	ps_calc_08	0.00000	0.00041	0.01344	0.00041	0.01385
4	ps_calc_05	0.00012	0.00029	0.00000	0.00041	0.00041
8	ps_calc_09	-0.00008	0.00030	0.00000	0.00038	0.00038
12	ps_calc_13	-0.00011	0.00025	0.02016	0.00036	0.02052
3	ps_calc_04	0.00016	0.00015	0.00000	0.00031	0.00031
29	ps_car_10_cat	0.00024	0.00003	0.00000	0.00027	0.00027
45	ps_ind_10_bin	0.00019	0.00008	0.00000	0.00027	0.00027

	id	ps_ind_01	ps_ind_02_cat	ps_ind_03	ps_ind_04_cat	ps_ind_06_bin	ps_ind_07_bin	ps_ind_08_bin	...	ps_calc_11	ps_calc_12	ps_calc_13	ps_calc_14	ps_calc_16_bin	ps_calc_17_bin	ps_calc_18_bin	ps_calc_19_bin	ps_calc_20_bin
0	7	2	2	5	1	0	1	0	...	9	1	5	8	1	1	0	0	1
1	9	1	1	7	0	0	0	1	...	3	1	1	9	1	1	0	1	0
2	13	5	4	9	1	0	0	1	...	4	2	7	7	1	1	0	1	0
3	16	0	1	2	0	1	0	0	...	2	2	4	9	0	0	0	0	0
4	17	0	2	0	1	1	0	0	...	3	1	1	3	0	0	1	1	0

	Data Type	num_na	num_unique	Category	Variable Type
target	int64	0	2	Binaria	Cualitativa
ps_calc_18_bin	int64	0	2	Binaria	Cualitativa
ps_calc_17_bin	int64	0	2	Binaria	Cualitativa
ps_calc_16_bin	int64	0	2	Binaria	Cualitativa
ps_calc_15_bin	int64	0	2	Binaria	Cualitativa
ps_calc_19_bin	int64	0	2	Binaria	Cualitativa
ps_ind_18_bin	int64	0	2	Binaria	Cualitativa
ps_ind_17_bin	int64	0	2	Binaria	Cualitativa
ps_ind_16_bin	int64	0	2	Binaria	Cualitativa
ps_ind_13_bin	int64	0	2	Binaria	Cualitativa
ps_ind_12_bin	int64	0	2	Binaria	Cualitativa
ps_calc_20_bin	int64	0	2	Binaria	Cualitativa
ps_ind_10_bin	int64	0	2	Binaria	Cualitativa
ps_ind_09_bin	int64	0	2	Binaria	Cualitativa
ps_ind_08_bin	int64	0	2	Binaria	Cualitativa
ps_ind_07_bin	int64	0	2	Binaria	Cualitativa
ps_ind_06_bin	int64	0	2	Binaria	Cualitativa
ps_ind_11_bin	int64	0	2	Binaria	Cualitativa
ps_ind_02_cat	int64	216	5	Cualitativa	Cualitativa
ps_ind_04_cat	int64	83	3	Cualitativa	Cualitativa
ps_car_11_cat	int64	0	104	Cualitativa	Continua
ps_car_10_cat	int64	0	3	Cualitativa	Cualitativa
ps_car_09_cat	int64	569	6	Cualitativa	Cualitativa
ps_car_08_cat	int64	0	2	Cualitativa	Cualitativa
ps_ind_05_cat	int64	5809	8	Cualitativa	Cualitativa
ps_car_06_cat	int64	0	18	Cualitativa	Cualitativa
ps_car_07_cat	int64	11489	3	Cualitativa	Cualitativa
ps_car_04_cat	int64	0	10	Cualitativa	Cualitativa
ps_car_03_cat	int64	411231	3	Cualitativa	Cualitativa
ps_car_02_cat	int64	5	3	Cualitativa	Cualitativa
ps_car_01_cat	int64	107	13	Cualitativa	Cualitativa
ps_car_05_cat	int64	266551	3	Cualitativa	Cualitativa
ps_calc_03	float64	0	10	Continua	Cualitativa
ps_calc_02	float64	0	10	Continua	Cualitativa
ps_calc_01	float64	0	10	Continua	Cualitativa
ps_car_15	float64	0	15	Continua	Cualitativa
ps_car_12	float64	1	184	Continua	Continua
ps_car_13	float64	0	70482	Continua	Continua
ps_reg_01	float64	0	10	Continua	Cualitativa
ps_reg_02	float64	0	19	Continua	Cualitativa
ps_reg_03	float64	107772	5013	Continua	Continua
ps_car_14	float64	42620	850	Continua	Continua
ps_ind_01	int64	0	8	Cont/Cual	Cualitativa
ps_ind_14	int64	0	5	Cont/Cual	Cualitativa
ps_ind_03	int64	0	12	Cont/Cual	Cualitativa
ps_ind_15	int64	0	14	Cont/Cual	Cualitativa
ps_calc_14	int64	0	24	Cont/Cual	Continua
ps_calc_13	int64	0	14	Cont/Cual	Cualitativa
ps_calc_12	int64	0	11	Cont/Cual	Cualitativa
ps_calc_10	int64	0	26	Cont/Cual	Continua
ps_calc_09	int64	0	8	Cont/Cual	Cualitativa
ps_calc_08	int64	0	11	Cont/Cual	Cualitativa
ps_calc_07	int64	0	10	Cont/Cual	Cualitativa
ps_calc_06	int64	0	11	Cont/Cual	Cualitativa
ps_calc_04	int64	0	6	Cont/Cual	Cualitativa
ps_car_11	int64	5	5	Cont/Cual	Cualitativa
ps_calc_11	int64	0	20	Cont/Cual	Cualitativa
ps_calc_05	int64	0	7	Cont/Cual	Cualitativa

	Feature	Gini	Information Value (IV)	Permutation Importance	VIF	KS
0	ps_calc_01	1.001044e-04	6.755897e-04	0.006720	NaN	NaN
1	ps_calc_02	4.726956e-04	4.922961e-04	0.013441	NaN	NaN
2	ps_calc_03	4.358367e-04	3.601328e-04	0.010080	NaN	NaN
3	ps_calc_04	1.581859e-04	1.469187e-04	0.000000	NaN	NaN
4	ps_calc_05	1.238698e-04	2.919458e-04	0.000000	NaN	NaN
5	ps_calc_06	1.743624e-07	9.493726e-04	0.026881	NaN	NaN
6	ps_calc_07	1.213284e-05	5.128267e-04	0.013441	NaN	NaN
7	ps_calc_08	1.743624e-06	4.088823e-04	0.013441	NaN	NaN
8	ps_calc_09	-8.423842e-05	2.967627e-04	0.000000	NaN	NaN
9	ps_calc_10	3.454968e-03	4.638004e-04	0.020161	1.000010	0.008748
10	ps_calc_11	-7.620515e-07	1.392707e-03	0.023521	NaN	NaN
11	ps_calc_12	-2.098402e-04	5.833618e-04	0.006720	NaN	NaN
12	ps_calc_13	-1.113164e-04	2.539179e-04	0.020161	NaN	NaN
13	ps_calc_14	2.907907e-03	3.185615e-04	0.003360	1.000004	0.004217
14	ps_calc_15_bin	-8.577890e-04	6.867809e-06	0.000000	NaN	NaN
15	ps_calc_16_bin	1.609098e-03	1.109028e-05	0.000000	NaN	NaN
16	ps_calc_17_bin	-4.512420e-04	8.240801e-07	0.006720	NaN	NaN
17	ps_calc_18_bin	1.333759e-03	8.678863e-06	0.013441	NaN	NaN
18	ps_calc_19_bin	-4.435504e-03	8.682940e-05	0.000000	NaN	NaN
19	ps_calc_20_bin	-2.061451e-03	3.290504e-05	0.000000	NaN	NaN
20	ps_car_01_cat	-3.214540e-04	3.670219e-02	0.235210	NaN	NaN
21	ps_car_02_cat	-6.322968e-02	2.522606e-02	-0.003360	NaN	NaN
22	ps_car_03_cat	6.276192e-02	1.026582e-02	0.114245	NaN	NaN
23	ps_car_04_cat	7.910204e-03	3.495814e-02	0.084004	NaN	NaN
24	ps_car_05_cat	3.309124e-02	1.963341e-05	0.010080	NaN	NaN
25	ps_car_06_cat	9.554776e-04	3.381718e-02	0.023521	NaN	NaN
26	ps_car_07_cat	-4.448442e-02	9.582240e-03	0.144486	NaN	NaN
27	ps_car_08_cat	-4.057461e-02	1.087619e-02	0.003360	NaN	NaN
28	ps_car_09_cat	6.846248e-03	1.678575e-02	0.016801	NaN	NaN
29	ps_car_10_cat	2.398088e-04	3.173514e-05	0.000000	NaN	NaN
30	ps_car_11	-4.398058e-03	1.275266e-02	0.000000	NaN	NaN
31	ps_car_11_cat	2.483150e-02	6.386553e-03	0.094084	1.003953	0.035152
32	ps_car_12	1.103094e-01	3.995435e-02	0.057123	2.212193	0.083747
33	ps_car_13	1.530936e-01	7.206788e-02	0.100804	1.913309	0.115247
34	ps_car_14	2.394807e-02	1.879454e-02	0.026881	1.414189	0.061229
35	ps_car_15	5.981435e-04	3.005593e-02	0.010080	NaN	NaN
36	ps_ind_01	4.136978e-03	1.176617e-02	0.003360	NaN	NaN
37	ps_ind_02_cat	4.465980e-03	1.078667e-03	0.235210	NaN	NaN
38	ps_ind_03	-1.781159e-03	2.879527e-02	0.060483	NaN	NaN
39	ps_ind_04_cat	2.607426e-02	2.912871e-03	0.369616	NaN	NaN
40	ps_ind_05_cat	8.701502e-03	2.999956e-02	0.332655	NaN	NaN
41	ps_ind_06_bin	-8.868646e-02	3.459194e-02	0.067203	NaN	NaN
42	ps_ind_07_bin	7.979267e-02	3.081699e-02	0.087364	NaN	NaN
43	ps_ind_08_bin	2.597142e-02	4.658925e-03	0.050402	NaN	NaN
44	ps_ind_09_bin	-1.707763e-02	1.999937e-03	0.023521	NaN	NaN
45	ps_ind_10_bin	1.869872e-04	7.717706e-05	0.000000	NaN	NaN
46	ps_ind_11_bin	4.447789e-04	1.049083e-04	0.000000	NaN	NaN
47	ps_ind_12_bin	4.029881e-03	1.468236e-03	0.000000	NaN	NaN
48	ps_ind_13_bin	4.039361e-04	1.454926e-04	0.000000	NaN	NaN
49	ps_ind_14	1.034105e-03	1.464092e-03	0.000000	NaN	NaN
50	ps_ind_15	-7.434278e-04	1.612273e-02	0.040322	NaN	NaN
51	ps_ind_16_bin	-7.017560e-02	2.113447e-02	0.084004	NaN	NaN
52	ps_ind_17_bin	6.450002e-02	3.288829e-02	0.117605	NaN	NaN
53	ps_ind_18_bin	8.761238e-03	5.785738e-04	0.000000	NaN	NaN
54	ps_reg_01	-3.228884e-04	2.400182e-02	0.050402	NaN	NaN
55	ps_reg_02	6.342803e-04	4.186385e-02	0.040322	NaN	NaN
56	ps_reg_03	9.806298e-02	3.916688e-02	0.043682	1.057116	0.086947

	id	ps_car_13	ps_car_12	ps_reg_03	ps_ind_06_bin	ps_ind_07_bin	ps_ind_17_bin	ps_ind_16_bin	ps_car_02_cat	ps_car_03_cat	ps_car_07_cat	ps_car_08_cat	ps_car_14	ps_reg_02
0	7	0.883679	0.404717	-0.464869	0	1	1	0	1	-1	1	0	-0.123259	0.2
1	9	0.618817	-0.868016	-0.310186	0	0	0	0	1	-1	1	1	0.454249	0.4
2	13	0.641586	-0.868016	0.010037	0	0	0	1	1	-1	1	1	-0.764710	0.0
3	16	0.542949	-0.191865	-1.107059	1	0	0	1	1	0	1	1	-1.862552	0.2
4	17	0.565832	-1.831224	0.332574	1	0	0	1	1	-1	1	1	-0.316330	0.6

Hiperparámetro	Explicación	Rango
`C`	Control de capacidad/fuerza de regularización (valores bajos = más penalización)	0.01 – 10
`class_weight`	Ajuste del peso en clases desbalanceadas	"balanced"
`solver`	Algoritmo numérico de optimización	["lbfgs", "liblinear"]
`max_iter`	Iteraciones máximas en la optimización	–
`model.fit`	Sin métricas internas: la evaluación se realiza externamente	–

Hiperparámetro	Explicación	Rango
`n_estimators`	Número de árboles	50 – 500
`max_depth`	Profundidad máxima	3 – 12
`learning_rate`	Tasa de aprendizaje	0.005 – 0.3
`scale_pos_weight`	Peso de la clase positiva según el desbalance	Calculado previamente
`subsample`	Fracción de muestras por árbol	0.6 – 1.0
`colsample_bytree`	Fracción de variables por árbol	0.6 – 1.0
`gamma`	Penalización de complejidad	0 – 5
`reg_alpha`	Regularización L1	0 – 1
`reg_lambda`	Regularización L2	0 – 1
`model.fit[eval_set]`	Conjunto de validación [(X_test, y_test)]	–
`model.fit[eval_metric]`	Métrica a monitorizar	–
`model.fit[early_stopping_rounds]`	Detención anticipada tras 50 iteraciones sin mejora	–

Hiperparámetro	Explicación	Rango
`num_leaves`	Número máximo de hojas	10 – 100
`learning_rate`	Tasa de aprendizaje	0.005 – 0.3
`n_estimators`	Número de árboles	50 – 500
`is_unbalance`	Compensación automática de clases	True
`feature_fraction`	Fracción de variables por iteración	0.6 – 1.0
`lambda_l1`	Regularización L1	0.0 – 1.0
`lambda_l2`	Regularización L2	0.0 – 1.0
`model.fit[eval_set]`	Conjunto de validación [(X_test, y_test)]	–
`model.fit[eval_metric]`	Métrica de evaluación	–
`model.fit[objective]`	Binary: obligatorio para clasificación binaria	–

Hiperparámetro	Explicación	Rango
`n_d, n_a`	Dimensión de decisión y atención	8 – 64
`n_steps`	Pasos de decisión	3 – 10
`gamma`	Penalización por complejidad	1.0 – 2.0
`lambda_sparse`	Regularización L1 para sparsity	0.001 – 0.1
`momentum`	Suavizado en actualizaciones	0.02 – 0.98
`model.fit[eval_set]`	Requiere arrays NumPy [(X_test, y_test)]	–
`model.fit[eval_metric]`	Métrica para monitorizar mejora	–
`model.fit[patience]`	Parada temprana tras N iteraciones sin mejora	–
`model.fit[max_epochs]`	Número máximo de épocas	–
`model.fit[batch_size]`	Tamaño del batch	–
`model.fit[virtual_batch_size]`	Batch virtual para normalización	–

Característica	TabNet	XGBoost / LightGBM
Enfoque	Red neuronal con atención	Árboles de boosting
Selección de variables	Automática	Manual
Valores nulos	No requiere imputación	Requiere imputación
Aprendizaje	Pasos de atención progresivos	Árboles secuenciales
Coste computacional	Alto	Moderado
Tamaño de dataset	Grande (miles o millones)	Cualquier tamaño

Categoría	Método / Framework	Técnica principal	Tipo de búsqueda	Referencias clave
Búsqueda clásica	Grid Search	Búsqueda exhaustiva	Determinista	Bergstra & Bengio, 2012
	Randomized Search	Muestreo aleatorio	Estocástica	Bergstra & Bengio, 2012
Optimización bayesiana	Bayesian Optimization	Modelado con Gaussian Process	Adaptativa	Snoek et al., 2012
	Hyperopt	Tree-structured Parzen Estimator (TPE)	Adaptativa	Bergstra et al., 2013
	Optuna	TPE + pruning (early stopping)	Adaptativa + eficiente	Akiba et al., 2019
Asignación de recursos	Hyperband	Sucesivos descartes con early stopping	Basada en rendimiento	Li et al., 2017
	BOHB (HpBandSter)	Bayesian Opt. + Hyperband	Adaptativa + recursos	Falkner et al., 2018
Metaheurísticas evolutivas	Genetic Algorithms	Evolución biológica simulada	Estocástica, heurística	DEAP library
	TPOT	AutoML basado en programación genética	Heurística + AutoML	Olson & Moore, 2016

	Modelo	Mejor Score	Mejor Trial	Nº de Trials
0	Logistic Regression	0.612074	2	10
1	XGBoost	0.613174	8	10
2	LightGBM	0.614129	3	10
3	TabNet	0.609591	4	10

	ROC-AUC	PR-AUC	Recall	F1-score	Precision	Accuracy
XGBoost	0.6117	0.0568	0.5545	0.0914	0.0498	0.5979
LogisticRegression	0.6114	0.0555	0.5469	0.0920	0.0502	0.6065
LightGBM	0.6109	0.0566	0.5582	0.0928	0.0506	0.6023
TabNet	0.5841	0.0487	0.0002	0.0005	0.1429	0.9635

Real \ Predicho	0 (Predicho)	1 (Predicho)
0 (Real)	TN	FP
1 (Real)	FN	TP

Característica	LIME	SHAP
Fundamento teórico	Aproximación local con modelo interpretable	Teoría de juegos (valores de Shapley)
Tipo de explicabilidad	Local	Local y global
Modelo-agnóstico	Sí	Sí (más eficiente en árboles)
Estabilidad	Dependiente del muestreo	Alta estabilidad
Costo computacional	Bajo	Medio - Alto
Coherencia teórica	No garantiza consistencia	Asegura propiedades deseables
Visualizaciones	Básicas	Avanzadas: beeswarm, waterfall, force plots

	id	ps_ind_01	ps_ind_02_cat	ps_ind_03	ps_ind_04_cat	ps_ind_06_bin	ps_ind_07_bin	ps_ind_08_bin	...	ps_calc_11	ps_calc_12	ps_calc_13	ps_calc_14	ps_calc_16_bin	ps_calc_17_bin	ps_calc_18_bin	ps_calc_19_bin	ps_calc_20_bin
0	7	2	2	5	1	0	1	0	...	9	1	5	8	1	1	0	0	1
1	9	1	1	7	0	0	0	1	...	3	1	1	9	1	1	0	1	0
2	13	5	4	9	1	0	0	1	...	4	2	7	7	1	1	0	1	0
3	16	0	1	2	0	1	0	0	...	2	2	4	9	0	0	0	0	0
4	17	0	2	0	1	1	0	0	...	3	1	1	3	0	0	1	1	0

	Logistic Regression	XGBoost	LightGBM	TabNet
C	0.528875	NaN	NaN	NaN
solver	0.471125	NaN	NaN	NaN
reg_lambda	NaN	0.586202	NaN	NaN
learning_rate	NaN	0.179487	0.649074	NaN
subsample	NaN	0.074384	NaN	NaN
reg_alpha	NaN	0.055256	NaN	NaN
n_estimators	NaN	0.051085	0.058087	NaN
max_depth	NaN	0.040157	NaN	NaN
gamma	NaN	0.008216	NaN	0.239190
colsample_bytree	NaN	0.005212	NaN	NaN
lambda_l1	NaN	NaN	0.164544	NaN
num_leaves	NaN	NaN	0.082291	NaN
lambda_l2	NaN	NaN	0.037389	NaN
feature_fraction	NaN	NaN	0.008615	NaN
lambda_sparse	NaN	NaN	NaN	0.302038
n_steps	NaN	NaN	NaN	0.275329
n_a	NaN	NaN	NaN	0.066660
n_d	NaN	NaN	NaN	0.064870
momentum	NaN	NaN	NaN	0.051913

Análisis y Predicción del Riesgo de Siniestro en Seguros de Automóviles

Un Estudio con Datos de Porto Seguro

Marc Román Porras Máster Universitario en Ciencia de Datos Universitat Oberta de Catalunya

Tabla de Contenidos:¶

1. Carga y Preparación Inicial del Dataset

Importación de librerías

Carga de datos y estructura inicial

2. Análisis exploratorio de datos (EDA)

Visualización del target

Análisis bivariante de variables vs target.

Análisis Bivariante: Variables Categóricas vs Target

Variables con mayor poder discriminativo visual

Variables dominadas por un solo nivel

Variables binarias o con clases desbalanceadas

Variables con muchos niveles o patrón difuso

Consideración del análisis visual

Análisis Bivariante: Variables Cuantitativas vs Target

Variables con diferencias visuales claras entre clases

Variables con patrones menos claros o dominadas por picos

Consideraciones sobre la forma de la distribución

Consideración final

3. Preparación de datos

Valores N/A

Comparativa de métodos de imputación para variables cuantitativas

Proceso de selección de variables. Reducción de la dimensionalidad del dataset de manera empírica:

Selección de Variables: Estrategia Combinada

1. Cálculo de indicadores por variable

2. Agregación de métricas: Score de selección

3. Umbral óptimo de selección con el método de Otsu

4. Resultado: Subconjunto de variables seleccionadas

Coeficiente de Gini

Relación con el estadístico D de Somers'

Interpretación numérica del Gini

Aplicabilidad:

Information Value (IV)

Definición formal del Weight of Evidence (WoE)

Cálculo e interpretación del Information Value (IV)

Aplicabilidad:

Importancia por Permutación (A partir de RF Naive)

Definición formal

Aplicabilidad:

Factor de Inflación de la Varianza (VIF)

Fórmula del VIF

Interpretación del VIF

Aplicabilidad:

Kolmogorov-Smirnov (KS)

Aplicabilidad:

Resumen del proceso de selección y justificación:

Criterio final: Dicotomización óptima del ranking mediante el Método de Otsu

Fundamento matemático detrás del método:

1. Probabilidades de clase acumuladas

2. Medias de clase y media total

3. Varianza intra-clase (minimización)

4. Varianza inter-clase (maximización)

Interpretación y aplicación práctica

Justificación de uso en este análisis

Conjunto de datos final: Short List

4. Modelización

Métricas de error para Datos Desbalanceados sobre target binario (0–1 de riesgo de siniestralidad)

Idiosincrasia de la Matriz de Confusión vs. Métricas AUC como elemento clave

Precision y Recall como métricas clave en un clasificador desbalanceado

1. En la matriz de confusión: el sesgo de la clase mayoritaria

2. En la curva AUC: PR-AUC vs. ROC-AUC

Consideración operativa

Modelos e Hiperparámetros

1️. Regresión Logística (LogisticRegression)

2️. XGBoost (XGBClassifier)

3️. LightGBM (LGBMClassifier)

4️. TabNet (TabNetClassifier)

Diferencias clave entre TabNet y soluciones Boosting

Tratamiento de los conjuntos de datos:

Procedimiento de Preparación del Dataset

Diseño de Modelos. Selección de Hiperparámetros con Optuna.

Justificación de la selección de Optuna como técnica de optimización¶

Selección de Hiperparámetros con Optuna:

Guardado:

5. Entrenamiento y Evaluación

Carga de resultados:

Entrenamiento final de Modelos:

Regresión Logística:

Marc Román Porras

Máster Universitario en Ciencia de Datos

Universitat Oberta de Catalunya

1️. Regresión Logística (`LogisticRegression`)

2️. XGBoost (`XGBClassifier`)

3️. LightGBM (`LGBMClassifier`)

4️. TabNet (`TabNetClassifier`)

Cuando se selecciona el top 5% de mayor riesgo para una auditoría o intervención, se debe verificar que:

El orden del score sea adecuado (discriminación: ROC-AUC).

La proporción predicha coincida con la observada, especialmente si se estiman pérdidas agregadas.

	id	ps_ind_01	ps_ind_02_cat	ps_ind_03	ps_ind_04_cat	ps_ind_06_bin	ps_ind_07_bin	ps_ind_08_bin	...	ps_calc_11	ps_calc_12	ps_calc_13	ps_calc_14	ps_calc_16_bin	ps_calc_17_bin	ps_calc_18_bin	ps_calc_19_bin	ps_calc_20_bin
0	7	2	2	5	1	0	1	0	...	9	1	5	8	1	1	0	0	1
1	9	1	1	7	0	0	0	1	...	3	1	1	9	1	1	0	1	0
2	13	5	4	9	1	0	0	1	...	4	2	7	7	1	1	0	1	0
3	16	0	1	2	0	1	0	0	...	2	2	4	9	0	0	0	0	0
4	17	0	2	0	1	1	0	0	...	3	1	1	3	0	0	1	1	0